diff --git a/.circleci/config.yml b/.circleci/config.yml
index 839f279c..5cde4c5d 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -27,8 +27,8 @@ jobs:
       - checkout
       - run: apt upgrade -y && apt update -y && apt install -y git
       - run: git submodule sync && git submodule update --init --recursive --remote
-      - run: chmod +x ./mitama_build.sh
-      - run: ./mitama_build.sh
+      - run: mkdir -p build && cd build && cmake .. && make -j5 && ctest 2>&1 | tee ./ctset.log
+  
 
 workflows:
   build:
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5f1cefee..5bbf48d6 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,11 +4,12 @@ set(CMAKE_CXX_STANDARD 17) # ...C++17
 set(CMAKE_CXX_STANDARD_REQUIRED ON) #...is required...
 set(CMAKE_CXX_EXTENSIONS OFF) #...without compiler extensions like gnu++17
 find_package(Threads REQUIRED)
-
+find_package(Boost 1.62.0 REQUIRED)
 ## Set our project name
 project(mitama-dimensional)
 
 include_directories(
+  PUBLIC ${Boost_INCLUDE_DIRS}
   PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/tests
   PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include
   PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/mitama-cpp-result/include
@@ -27,7 +28,6 @@ add_subdirectory(tests/basic-tests)
 add_subdirectory(tests/delta-tests)
 add_subdirectory(tests/derived-unit-tests)
 add_subdirectory(tests/format-io-tests)
+add_subdirectory(tests/literal-tests)
 add_subdirectory(tests/math-tests)
 add_subdirectory(tests/nonsi-unit-tests)
-add_subdirectory(tests/refinement-tests)
-add_subdirectory(tests/static-quantity-tests)
diff --git a/README.md b/README.md
index 69e2e650..6ad28119 100644
--- a/README.md
+++ b/README.md
@@ -18,7 +18,6 @@ Please refer to the [document](https://loligothick.github.io/mitama-dimensional/
 - pre defined SI derived units
 - **USER DEFINED DIMENSION**
 - formatted output
-- dimensional refinement
 
 ## Examples
 
@@ -99,31 +98,6 @@ int main() {
 }
 ```
 
-- [dimensional refinement](https://loligothick.github.io/mitama-dimensional/UserManual/dimensional-refinement/)
-  
-```cpp
-#include <dimensional/quantity.hpp>
-#include <dimensional/arithmetic.hpp>
-#include <dimensional/systems/si/all.hpp>
-#include <dimensional/systems/si/derived_units/area.hpp>
-#include <dimensional/refinement.hpp>
-
-int main() {
-    namespace si = mitama::systems::si;
-    using mitama::accepts_for, mitama::sym::L;
-
-    // width = 2 m
-    mitama::quantity_t<si::meter_t, int> width = 2;
-    // height = 3 mm
-    mitama::quantity_t<si::millimeter_t, int> height = 3;
-    // area = 6000 mm^2
-    mitama::quantity_t area = accepts_for<L<2>> |= width * height;
-    //                        ^~~~~~~~~~~~~~~~
-    //                        refine for L^2
-}
-```
-
-
 - [user defined dimension example](https://loligothick.github.io/mitama-dimensional/UserManual/user-defined-dimension/)
 
 
diff --git a/example/overview.cpp b/example/overview.cpp
index 7f4e8bcd..93d9a7fe 100644
--- a/example/overview.cpp
+++ b/example/overview.cpp
@@ -5,7 +5,7 @@
 #include <dimensional/systems/si/derived_units/area.hpp>
 #include <dimensional/systems/si/derived_units/angle.hpp>
 #include <dimensional/io.hpp>
-#include <dimensional/refinement.hpp>
+
 #include <dimensional/systems/si/prefix.hpp>
 #include <dimensional/math/all.hpp>
 #include <dimensional/systems/currency/jpy.hpp>
diff --git a/include/dimensional/dimensional.hpp b/include/dimensional/dimensional.hpp
new file mode 100644
index 00000000..8ae100ea
--- /dev/null
+++ b/include/dimensional/dimensional.hpp
@@ -0,0 +1,63 @@
+#ifndef MITAMA_DIMENSIONAL_HPP
+#define MITAMA_DIMENSIONAL_HPP
+#include <mitama/dimensional/fwd/dimensional_fwd.hpp>
+#include <mitama/dimensional/fwd/system.hpp>
+#include <mitama/dimensional/mitamagic/utility_ext.hpp>
+#include <mitama/dimensional/mitamagic/type_traits_ext.hpp>
+#include <mitama/dimensional/mitamagic/ratio_ext.hpp>
+#include <mitama/dimensional/mitamagic/type_list.hpp>
+#include <type_traits>
+
+namespace mitama::mitamagic {
+template <class T, class... Types>
+inline constexpr std::size_t dimension_count_v =
+    (static_cast<std::size_t>(std::is_same_v<typename T::dimension_type,
+                                             typename Types::dimension_type>) +
+     ... + std::size_t{}); // type count meta-function
+} // namespace mitama::mitamagic
+
+namespace mitama {
+
+template < class >
+struct si_base_units {};
+
+template <int I, class Dim, class Exponent> struct dimension_tag {};
+
+template <class... Units>
+struct dimensional_t : private Units::tag... // for Dimensional tags
+{
+  template < class T >
+  struct is_wildcard : std::is_same<T, system<>> {};
+  // sanity check for duplicate
+  static_assert(std::conjunction_v<std::bool_constant<
+                    (mitamagic::dimension_count_v<Units, Units...> == 1)>...>,
+                "same dimension is not allowed");
+  // sanity check for system
+  static_assert(mitamagic::tlist_all_same_v<
+                  mitamagic::tlist_remove_if_t<is_wildcard,
+                    mitamagic::type_list<typename Units::system_type...>>>,
+                "different units within a dimension");
+  static constexpr std::size_t value = sizeof...(Units);
+  using system_type
+    = mitamagic::tlist_element_t<0,
+        std::conditional_t<
+          std::is_same_v<
+            mitamagic::type_list<>,
+            mitamagic::tlist_remove_if_t<is_wildcard,
+              mitamagic::type_list<typename Units::system_type...>
+            >
+          >,
+          mitamagic::type_list<system<>>,
+          mitamagic::tlist_remove_if_t<is_wildcard,
+            mitamagic::type_list<typename Units::system_type...>
+          >
+        >
+      >;
+};
+
+template <class... Units>
+using make_dimensional_t = si_base_units<dimensional_t<Units...>>;
+
+
+} // namespace mitama
+#endif
diff --git a/include/dimensional/quantity.hpp b/include/dimensional/quantity.hpp
new file mode 100644
index 00000000..24d9ab55
--- /dev/null
+++ b/include/dimensional/quantity.hpp
@@ -0,0 +1,413 @@
+#ifndef MITAMA_DIMENSIONAL_QUANTITY_HPP
+#define MITAMA_DIMENSIONAL_QUANTITY_HPP
+#include <mitama/dimensional/fwd/quantity_fwd.hpp>
+#include <mitama/dimensional/dimensional_traits.hpp>
+
+namespace mitama {
+
+template < class >
+struct dimensionless_converter {};
+
+template < template <class> class Synonym, class T, class... B >
+struct dimensionless_converter<quantity_t<Synonym<dimensional_t<>>, T, system<B...>>> {
+  operator T() const { return static_cast<quantity_t<Synonym<dimensional_t<>>, T> const*>(this)->value(); }
+};
+
+
+// Into Trait
+template < class Quantity >
+class Into;
+
+template < template <class> class Synonym, class T, class... Units, class... B >
+class Into<quantity_t<Synonym<dimensional_t<Units...>>, T, system<B...>>> {
+  quantity_t<Synonym<dimensional_t<Units...>>, T, system<B...>> const& quantity_;
+public:
+  constexpr explicit Into(quantity_t<Synonym<dimensional_t<Units...>>, T, system<B...>> const& q): quantity_(q) {}
+  // explicitly deleted
+  Into() = delete;
+  Into(Into const&) = delete;
+  Into(Into&&) = delete;
+  Into& operator=(Into const&) = delete;
+  Into& operator=(Into&&) = delete;
+
+  template < class To,
+            std::enable_if_t<is_same_dimensional_v<
+              remove_dim_if_t<has_dimensionless_tag, To>,
+              remove_dim_if_t<has_dimensionless_tag, quantity_t<Synonym<dimensional_t<Units...>>, T, system<B...>>>>
+    , bool> = false >
+  constexpr operator To() const {
+    return To(quantity_.value());
+  }
+};
+
+
+template < class To, class From >
+inline constexpr std::enable_if_t<is_dimensional_convertible_v<From, To>, To>
+dimensional_convert(From const& from) {
+  if constexpr (dimensional_ext::is_complete_type_v<converter<From, To>>){
+    return To{::mitama::converter<From, To>::convert(from)};
+  }
+  else {
+    return To{::mitama::mitamagic::converted_value<To>(from)};
+  }
+}
+
+} // namespace mitama
+
+namespace mitama {
+
+template <class T, template <class> class Synonym, class...Units, class... B>
+class quantity_t<Synonym<dimensional_t<Units...>>, T, system<B...>>
+  : public dimensionless_converter<quantity_t<Synonym<dimensional_t<Units...>>, T>>
+{
+  T value_;
+public:
+  using value_type = T;
+  using dimension_type = dimensional_t<Units...>;
+  using system_type = system<B...>;
+
+  constexpr quantity_t(): value_{} {}
+
+  template < class Dimension, auto Value,
+      std::enable_if_t<
+        std::conjunction_v<
+          std::is_convertible<std::decay_t<decltype(Value)>, T>,
+          is_same_dimensional<dimension_type, Dimension>>
+    , bool> = false>
+  constexpr quantity_t(static_quantity_t<Dimension, Value>) noexcept
+    : value_(Value)
+  {}
+
+  template < template <auto> class Pred,
+             class Dimension,
+             class U,
+      std::enable_if_t<
+        std::conjunction_v<
+          std::is_convertible<U, T>>
+    , bool> = false>
+  constexpr quantity_t(refined<Pred, quantity_t<Dimension, U>> refined_) noexcept
+    : quantity_t(refined_.get())
+  {}
+
+  template <class U = T,
+      std::enable_if_t<
+        std::conjunction_v<
+          std::is_constructible<T, U>,
+          std::is_convertible<U, T>>
+    , bool> = false>
+  constexpr quantity_t(U &&u) : value_(std::forward<U>(u)) {}
+
+  template <class U = T,
+      std::enable_if_t<
+        std::conjunction_v<
+          std::is_constructible<T, U>,
+          std::negation<std::is_convertible<U, T>>>
+    , bool> = false>
+  explicit constexpr quantity_t(U &&u) : value_{std::forward<U>(u)} {}
+
+  template <class... Args,
+      std::enable_if_t<
+          std::is_constructible_v<T, Args&&...>
+    , bool> = false>
+  explicit constexpr quantity_t(std::in_place_t, Args&& ...args)
+    : value_(std::forward<Args>(args)...) {}
+
+  template <class U, class... Args,
+      std::enable_if_t<
+          std::is_constructible_v<T, std::initializer_list<U>, Args&&...>
+    , bool> = false>
+  constexpr explicit quantity_t(std::in_place_t, std::initializer_list<U> il, Args&&... args)
+    : value_(il, std::forward<Args>(args)...) {}
+
+  template <
+      class D, class U, class S,
+      std::enable_if_t<is_same_dimensional_v<quantity_t, quantity_t<D, U, S>> &&
+                           std::is_constructible_v<T, U> &&
+                           std::is_convertible_v<U, T>,
+                       bool> = false>
+  constexpr quantity_t(quantity_t<D, U, S> const &o)
+      : value_(mitamagic::converted_value<quantity_t>(o)) {}
+
+  template <
+      class D, class U, class S,
+      std::enable_if_t<is_same_dimensional_v<quantity_t, quantity_t<D, U, S>> &&
+                           std::is_constructible_v<T, U> &&
+                           !std::is_convertible_v<U, T>,
+                       bool> = false>
+  explicit constexpr quantity_t(quantity_t<D, U, S> const &o)
+      : value_{mitamagic::converted_value<quantity_t>(o)} {}
+
+  template <
+      class D, class U, class S,
+      std::enable_if_t<dimensional_ext::is_complete_type_v<::mitama::converter<quantity_t<D, U, S>, quantity_t>> &&
+                           std::is_constructible_v<T, U> &&
+                           std::is_convertible_v<U, T>,
+                       bool> = false>
+  constexpr quantity_t(quantity_t<D, U, S> const &o)
+      : value_(::mitama::converter<quantity_t<D, U>, quantity_t>::convert(o)) {}
+
+  template <
+      class D, class U, class S,
+      std::enable_if_t<dimensional_ext::is_complete_type_v<::mitama::converter<quantity_t<D, U, S>, quantity_t>> &&
+                           std::is_constructible_v<T, U> &&
+                           !std::is_convertible_v<U, T>,
+                       bool> = false>
+  explicit constexpr quantity_t(quantity_t<D, U, S> const &o)
+      : value_{::mitama::converter<quantity_t<D, U>, quantity_t>::convert(o)} {}
+
+  template <
+      class D, class U, class S,
+      std::enable_if_t<is_same_dimensional_v<quantity_t, quantity_t<D, U, S>> &&
+                           std::is_convertible_v<U, T>,
+                       bool> = false>
+  constexpr quantity_t &operator=(quantity_t<D, U, S> const &o) & {
+    this->value_ = mitamagic::converted_value<quantity_t>(o);
+    return *this;
+  }
+
+  template <
+      class D, class U, class S,
+      std::enable_if_t<dimensional_ext::is_complete_type_v<::mitama::converter<quantity_t<D, U, S>, quantity_t>> &&
+                           std::is_convertible_v<U, T>,
+                       bool> = false>
+  constexpr quantity_t &operator=(quantity_t<D, U, S> const &o) & {
+    this->value_ = ::mitama::converter<quantity_t<D, U>, quantity_t>::convert(o);
+    return *this;
+  }
+
+  constexpr T value() const { return value_; }
+
+  template < class F >
+  constexpr auto validate(F&& validator) const & {
+    return std::forward<F>(validator)(*this);
+  }
+  template < class F >
+  constexpr auto validate(F&& validator) && {
+    return std::forward<F>(validator)(std::move(*this));
+  }
+
+  template <
+      class D, class U,
+      std::enable_if_t<
+        std::conjunction_v<
+          dimensional_ext::is_complete_type<::mitama::converter<quantity_t<D, U, system_type>, quantity_t>>,
+          dimensional_ext::is_greater_or_equal_comparable_with<T, U>>
+        , bool> = false>
+  constexpr bool operator==(quantity_t<D, U, system_type> const &o) const {
+    return this->value_ == ::mitama::converter<quantity_t<D, U>, quantity_t>::convert(o);
+  }
+
+  template <
+      class D, class U,
+      std::enable_if_t<
+        std::conjunction_v<
+          is_same_dimensional<quantity_t, quantity_t<D, U, system_type>>,
+          dimensional_ext::is_greater_or_equal_comparable_with<T, U>>
+        , bool> = false>
+  constexpr bool operator==(quantity_t<D, U, system_type> const &o) const {
+    auto [l, r] = mitamagic::scaler<dimension_type, typename quantity_t<D, U>::dimension_type>::template value<std::common_type_t<T, U>>();
+    return l * this->value() == r * o.value();
+  }
+
+  template <
+      class D, class U,
+      std::enable_if_t<
+        std::conjunction_v<
+          dimensional_ext::is_complete_type<::mitama::converter<quantity_t<D, U, system_type>, quantity_t>>,
+          dimensional_ext::is_notequal_comparable_with<T, U>>
+        , bool> = false>
+  constexpr bool operator!=(quantity_t<D, U, system_type> const &o) const {
+    return this->value_ != ::mitama::converter<quantity_t<D, U>, quantity_t>::convert(o);
+  }
+
+  template <
+      class D, class U,
+      std::enable_if_t<
+        std::conjunction_v<
+          is_same_dimensional<quantity_t, quantity_t<D, U, system_type>>,
+          dimensional_ext::is_notequal_comparable_with<T, U>>
+        , bool> = false>
+  constexpr bool operator!=(quantity_t<D, U, system_type> const &o) const {
+    auto [l, r] = mitamagic::scaler<dimension_type, typename quantity_t<D, U>::dimension_type>::template value<std::common_type_t<T, U>>();
+    return l * this->value() != r * o.value();
+  }
+
+  template <
+      class D, class U,
+      std::enable_if_t<
+        std::conjunction_v<
+          dimensional_ext::is_complete_type<::mitama::converter<quantity_t<D, U, system_type>, quantity_t>>,
+          dimensional_ext::is_less_comparable_with<T, U>>
+        , bool> = false>
+  constexpr bool operator<(quantity_t<D, U, system_type> const &o) const {
+    return this->value_ < ::mitama::converter<quantity_t<D, U>, quantity_t>::convert(o);
+  }
+
+  template <
+      class D, class U,
+      std::enable_if_t<
+        std::conjunction_v<
+          is_same_dimensional<quantity_t, quantity_t<D, U, system_type>>,
+          dimensional_ext::is_less_comparable_with<T, U>>
+        , bool> = false>
+  constexpr bool operator<(quantity_t<D, U, system_type> const &o) const {
+    auto [l, r] = mitamagic::scaler<dimension_type, typename quantity_t<D, U>::dimension_type>::template value<std::common_type_t<T, U>>();
+    return l * this->value() < r * o.value();
+  }
+
+  template <
+      class D, class U,
+      std::enable_if_t<
+        std::conjunction_v<
+          dimensional_ext::is_complete_type<::mitama::converter<quantity_t<D, U, system_type>, quantity_t>>,
+          dimensional_ext::is_less_or_equal_comparable_with<T, U>>
+        , bool> = false>
+  constexpr bool operator<=(quantity_t<D, U, system_type> const &o) const {
+    return this->value_ <= ::mitama::converter<quantity_t<D, U>, quantity_t>::convert(o);
+  }
+
+  template <
+      class D, class U,
+      std::enable_if_t<
+        std::conjunction_v<
+          is_same_dimensional<quantity_t, quantity_t<D, U, system_type>>,
+          dimensional_ext::is_less_or_equal_comparable_with<T, U>>
+        , bool> = false>
+  constexpr bool operator<=(quantity_t<D, U, system_type> const &o) const {
+    auto [l, r] = mitamagic::scaler<dimension_type, typename quantity_t<D, U>::dimension_type>::template value<std::common_type_t<T, U>>();
+    return l * this->value() <= r * o.value();
+  }
+
+  template <
+      class D, class U,
+      std::enable_if_t<
+        std::conjunction_v<
+          dimensional_ext::is_complete_type<::mitama::converter<quantity_t<D, U, system_type>, quantity_t>>,
+          dimensional_ext::is_greater_comparable_with<T, U>>
+        , bool> = false>
+  constexpr bool operator>(quantity_t<D, U, system_type> const &o) const {
+    return this->value_ > ::mitama::converter<quantity_t<D, U>, quantity_t>::convert(o);
+  }
+
+  template <
+      class D, class U,
+      std::enable_if_t<
+        std::conjunction_v<
+          is_same_dimensional<quantity_t, quantity_t<D, U, system_type>>,
+          dimensional_ext::is_greater_comparable_with<T, U>>
+        , bool> = false>
+  constexpr bool operator>(quantity_t<D, U, system_type> const &o) const {
+    auto [l, r] = mitamagic::scaler<dimension_type, typename quantity_t<D, U>::dimension_type>::template value<std::common_type_t<T, U>>();
+    return l * this->value() > r * o.value();
+  }
+
+  template <
+      class D, class U,
+      std::enable_if_t<
+        std::conjunction_v<
+          dimensional_ext::is_complete_type<::mitama::converter<quantity_t<D, U, system_type>, quantity_t>>,
+          dimensional_ext::is_greater_or_equal_comparable_with<T, U>>
+        , bool> = false>
+  constexpr bool operator>=(quantity_t<D, U, system_type> const &o) const {
+    return this->value_ >= ::mitama::converter<quantity_t<D, U>, quantity_t>::convert(o);
+  }
+
+  template <
+      class D, class U,
+      std::enable_if_t<
+        std::conjunction_v<
+          is_same_dimensional<quantity_t, quantity_t<D, U, system_type>>,
+          dimensional_ext::is_greater_or_equal_comparable_with<T, U>>
+        , bool> = false>
+  constexpr bool operator>=(quantity_t<D, U, system_type> const &o) const {
+    auto [l, r] = mitamagic::scaler<dimension_type, typename quantity_t<D, U>::dimension_type>::template value<std::common_type_t<T, U>>();
+    return l * this->value() >= r * o.value();
+  }
+
+  auto operator-() const {
+    if constexpr (std::is_integral_v<T>) {
+      return quantity_t<Synonym<dimensional_t<Units...>>, decltype(-std::declval<T>()), system<B...>>{ -value_ };
+    }
+    else {
+      return quantity_t{ -value_ };
+    }
+  }
+  auto operator+() const {
+    if constexpr (std::is_integral_v<T>) {
+      return quantity_t<Synonym<dimensional_t<Units...>>, decltype(+std::declval<T>()), system<B...>>{ +value_ };
+    }
+    else {
+      return quantity_t{ +value_ };
+    }
+  }
+
+  Into<quantity_t> into() const& {
+    return Into<quantity_t>(*this);
+  }
+};
+
+template < class Dim, auto Value >
+quantity_t(static_quantity_t<Dim, Value>) -> quantity_t<Dim, decltype(Value)>;
+
+template < template <auto> class Pred, class Dim, class T >
+quantity_t(refined<Pred, quantity_t<Dim, T>>) -> quantity_t<Dim, T>;
+
+namespace mitamagic {
+template <class Dim> struct into_dimensional;
+
+template <int I, class Dim> struct into_dimensional<units_t<I, Dim>> {
+  using type = si_base_units<dimensional_t<units_t<I, Dim>>>;
+};
+
+template <class... Units> struct into_dimensional<dimensional_t<Units...>> {
+  using type = si_base_units<dimensional_t<Units...>>;
+};
+
+template <template<class>class Synonym, class... Units> struct into_dimensional<Synonym<dimensional_t<Units...>>> {
+  using type = Synonym<dimensional_t<Units...>>;
+};
+
+template <class Unit>
+using into_dimensional_t = typename into_dimensional<Unit>::type;
+} // namespace mitamagic
+
+} // namespace mitama
+
+namespace mitama {
+
+template <class U1, class U2,
+          std::enable_if_t<
+            std::conjunction_v<is_dimensional_quantifier<U1>, is_dimensional_quantifier<U2>>
+        , bool> = false>
+constexpr mitamagic::quotient_t<mitamagic::into_dimensional_t<U1>,
+                                mitamagic::into_dimensional_t<U2>>
+operator*(U1, U2) {
+  return {};
+}
+
+template <class U1, class U2,
+          std::enable_if_t<std::conjunction_v<is_dimensional_quantifier<U1>, is_dimensional_quantifier<U2>>, bool> =
+              false>
+constexpr mitamagic::quotient_t<
+    mitamagic::into_dimensional_t<U1>,
+    mitamagic::inverse_t<mitamagic::into_dimensional_t<U2>>>
+operator/(U1, U2) {
+  return {};
+}
+
+template <template <class> class Syn, class Dim, class T>
+constexpr
+std::enable_if_t<
+  is_dimensional_quantifier<Syn<Dim>>::value,
+  quantity_t<Syn<Dim>, std::decay_t<T>, typename Dim::system_type>>
+operator|(T &&t, Syn<Dim>) {
+  return { mitama::decay_copy(std::forward<T>(t)) };
+}
+
+using dimless_t = si_base_units<dimensional_t<>>;
+
+template <class T, class Unit, class... Units>
+using quantity_for = std::decay_t<decltype(std::declval<T>() | (std::declval<Unit>() * ... * std::declval<Units>()))>;
+
+} // namespace mitama
+#endif
diff --git a/include/dimensional/systems/si/base_units/ampere.hpp b/include/dimensional/systems/si/base_units/ampere.hpp
new file mode 100644
index 00000000..0ec2ecdb
--- /dev/null
+++ b/include/dimensional/systems/si/base_units/ampere.hpp
@@ -0,0 +1,58 @@
+#ifndef MITAMA_DIMENSIONAL_SI_UNITS_AMPERE_HPP
+#define MITAMA_DIMENSIONAL_SI_UNITS_AMPERE_HPP
+#include <mitama/dimensional/systems/si/base_units/fwd/si_base_units.hpp>
+#include <mitama/dimensional/systems/si/prefix.hpp>
+#include <mitama/dimensional/units.hpp>
+
+namespace mitama::systems::si {
+
+using ampere_t = typename ampere_base_unit::unit_type_with_system<::mitama::systems::si::system>;
+
+using milliampere_t = scaled_unit_t<ampere_t, std::milli>;
+using microampere_t = scaled_unit_t<ampere_t, std::micro>;
+using nanoampere_t = scaled_unit_t<ampere_t, std::nano>;
+
+using kiloampere_t = scaled_unit_t<ampere_t, std::kilo>;
+using megaampere_t = scaled_unit_t<ampere_t, std::mega>;
+using teraampere_t = scaled_unit_t<ampere_t, std::tera>;
+
+template < std::intmax_t N = 1 >
+using ampere_ = powered_t<ampere_t, N>;
+
+template < std::intmax_t N = 1 >
+using milliampere_ = powered_t<milliampere_t, N>;
+template < std::intmax_t N = 1 >
+using microampere_ = powered_t<microampere_t, N>;
+template < std::intmax_t N = 1 >
+using nanoampere_ = powered_t<nanoampere_t, N>;
+
+template < std::intmax_t N = 1 >
+using kiloampere_ = powered_t<kiloampere_t, N>;
+template < std::intmax_t N = 1 >
+using megaampere_ = powered_t<megaampere_t, N>;
+template < std::intmax_t N = 1 >
+using teraampere_ = powered_t<teraampere_t, N>;
+
+
+inline constexpr ampere_t amperes{};
+
+inline constexpr milliampere_t milliamperes{};
+inline constexpr microampere_t microamperes{};
+inline constexpr nanoampere_t nanoamperes{};
+
+inline constexpr kiloampere_t kiloamperes{};
+inline constexpr megaampere_t megaamperes{};
+
+
+template < std::intmax_t N = 1 > inline constexpr powered_t<ampere_t, N> ampere{};
+
+template < std::intmax_t N = 1 > inline constexpr powered_t<milliampere_t, N> milliampere{};
+template < std::intmax_t N = 1 > inline constexpr powered_t<microampere_t, N> microampere{};
+template < std::intmax_t N = 1 > inline constexpr powered_t<nanoampere_t, N> nanoampere{};
+
+template < std::intmax_t N = 1 > inline constexpr powered_t<kiloampere_t, N> kiloampere{};
+template < std::intmax_t N = 1 > inline constexpr powered_t<megaampere_t, N> megaampere{};
+
+}
+
+#endif
diff --git a/include/dimensional/systems/si/base_units/fwd/si_base_units.hpp b/include/dimensional/systems/si/base_units/fwd/si_base_units.hpp
new file mode 100644
index 00000000..3636d4b5
--- /dev/null
+++ b/include/dimensional/systems/si/base_units/fwd/si_base_units.hpp
@@ -0,0 +1,41 @@
+#ifndef MITAMA_DIMENSIONAL_SI_BASE_UNITS_FWD_HPP
+#define MITAMA_DIMENSIONAL_SI_BASE_UNITS_FWD_HPP
+#include <mitama/dimensional/systems/si/base_dimension/electric_current.hpp>
+#include <mitama/dimensional/systems/si/base_dimension/luminous_intensity.hpp>
+#include <mitama/dimensional/systems/si/base_dimension/thermodynamic_temperature.hpp>
+#include <mitama/dimensional/systems/si/base_dimension/mass.hpp>
+#include <mitama/dimensional/systems/si/base_dimension/length.hpp>
+#include <mitama/dimensional/systems/si/base_dimension/amount_of_substance.hpp>
+#include <mitama/dimensional/systems/si/base_dimension/time.hpp>
+#include <mitama/dimensional/systems/si/base_dimension/angle.hpp>
+#include <mitama/dimensional/systems/si/base_dimension/solid_angle.hpp>
+#include <mitama/dimensional/units.hpp>
+#include <mitama/dimensional/system.hpp>
+
+namespace mitama::systems::si {
+using ampere_base_unit = base_units<electric_current, 0>;
+using candela_base_unit = base_units<luminous_intensity, 0>;
+using kelvin_base_unit = base_units<thermodynamic_temperature, 0>;
+using kilogram_base_unit = base_units<mass, 0>;
+using meter_base_unit = base_units<length, 0>;
+using metre_base_unit = base_units<length, 0>;
+using mole_base_unit = base_units<amount_of_substance, 0>;
+using second_base_unit = base_units<time, 0>;
+using angle_base_unit = base_units<angle, 0>;
+using solid_angle_base_unit = base_units<solid_angle, 0>;
+
+using system
+    = ::mitama::system<
+        ampere_base_unit,
+        candela_base_unit,
+        kelvin_base_unit,
+        kilogram_base_unit,
+        meter_base_unit,
+        mole_base_unit,
+        second_base_unit,
+        angle_base_unit,
+        solid_angle_base_unit
+    >;
+}
+
+#endif
diff --git a/include/mitama/dimensional/arithmetic.hpp b/include/mitama/dimensional/arithmetic.hpp
index 94800a7e..b50223ee 100644
--- a/include/mitama/dimensional/arithmetic.hpp
+++ b/include/mitama/dimensional/arithmetic.hpp
@@ -14,7 +14,7 @@ template <class L, class R,
           std::enable_if_t<
             std::conjunction_v<
                 is_same_dimensional<std::decay_t<L>, std::decay_t<R>>,
-                is_addable_with<typename std::decay_t<L>::value_type, typename std::decay_t<R>::value_type>>
+                dimensional_ext::is_addable_with<typename std::decay_t<L>::value_type, typename std::decay_t<R>::value_type>>
         , bool> = false>
 constexpr auto
 operator+(L &&lhs, R &&rhs)
@@ -37,7 +37,7 @@ template <class L, class R,
           std::enable_if_t<
             std::conjunction_v<
                 is_same_dimensional<std::decay_t<L>, std::decay_t<R>>,
-                is_subtractible_with<typename std::decay_t<L>::value_type, typename std::decay_t<R>::value_type>>
+                dimensional_ext::is_subtractible_with<typename std::decay_t<L>::value_type, typename std::decay_t<R>::value_type>>
         , bool> = false>
 constexpr auto
 operator-(L &&lhs, R &&rhs)
@@ -60,7 +60,7 @@ template <class L, class R,
           std::enable_if_t<std::conjunction_v<
             is_quantity<std::decay_t<L>>,
             is_quantity<std::decay_t<R>>,
-            is_multipliable_with<typename std::decay_t<L>::value_type, typename std::decay_t<R>::value_type>>
+            dimensional_ext::is_multipliable_with<typename std::decay_t<L>::value_type, typename std::decay_t<R>::value_type>>
         , bool> = false>
 constexpr auto
 operator*(L &&lhs, R &&rhs)
@@ -82,7 +82,7 @@ template <class L,
           std::enable_if_t<
             std::conjunction_v<
                 is_quantity<std::decay_t<L>>,
-                is_multipliable<typename std::decay_t<L>::value_type>>
+                dimensional_ext::is_multipliable<typename std::decay_t<L>::value_type>>
         , bool> = false>
 constexpr auto
 operator*(L &&lhs, typename std::decay_t<L>::value_type const& rhs)
@@ -94,7 +94,7 @@ template <class R,
           std::enable_if_t<
             std::conjunction_v<
                 is_quantity<std::decay_t<R>>,
-                is_multipliable<typename std::decay_t<R>::value_type>>
+                dimensional_ext::is_multipliable<typename std::decay_t<R>::value_type>>
         , bool> = false>
 constexpr auto
 operator*(typename std::decay_t<R>::value_type const& lhs, R&& rhs)
@@ -106,7 +106,7 @@ template <class L, class R,
           std::enable_if_t<std::conjunction_v<
             is_quantity<std::decay_t<L>>,
             is_quantity<std::decay_t<R>>,
-            is_dividable_with<typename std::decay_t<L>::value_type, typename std::decay_t<R>::value_type>>
+            dimensional_ext::is_dividable_with<typename std::decay_t<L>::value_type, typename std::decay_t<R>::value_type>>
         , bool> = false>
 constexpr auto
 operator/(L &&lhs, R &&rhs)
@@ -123,7 +123,7 @@ template <class L,
           std::enable_if_t<
             std::conjunction_v<
                 is_quantity<std::decay_t<L>>,
-                is_dividable<typename std::decay_t<L>::value_type>>
+                dimensional_ext::is_dividable<typename std::decay_t<L>::value_type>>
         , bool> = false>
 constexpr auto
 operator/(L &&lhs, typename std::decay_t<L>::value_type const& rhs)
@@ -135,7 +135,7 @@ template <class R,
           std::enable_if_t<
             std::conjunction_v<
                 is_quantity<std::decay_t<R>>,
-                is_dividable<typename std::decay_t<R>::value_type>>
+                dimensional_ext::is_dividable<typename std::decay_t<R>::value_type>>
         , bool> = false>
 constexpr auto
 operator/(typename std::decay_t<R>::value_type const& lhs, R&& rhs)
diff --git a/include/mitama/dimensional/dimensional.hpp b/include/mitama/dimensional/dimensional.hpp
index 07610049..8ae100ea 100644
--- a/include/mitama/dimensional/dimensional.hpp
+++ b/include/mitama/dimensional/dimensional.hpp
@@ -32,12 +32,27 @@ struct dimensional_t : private Units::tag... // for Dimensional tags
   static_assert(std::conjunction_v<std::bool_constant<
                     (mitamagic::dimension_count_v<Units, Units...> == 1)>...>,
                 "same dimension is not allowed");
-   // sanity check for system
-   static_assert(mitamagic::tlist_all_same_v<
+  // sanity check for system
+  static_assert(mitamagic::tlist_all_same_v<
                   mitamagic::tlist_remove_if_t<is_wildcard,
                     mitamagic::type_list<typename Units::system_type...>>>,
                 "different units within a dimension");
   static constexpr std::size_t value = sizeof...(Units);
+  using system_type
+    = mitamagic::tlist_element_t<0,
+        std::conditional_t<
+          std::is_same_v<
+            mitamagic::type_list<>,
+            mitamagic::tlist_remove_if_t<is_wildcard,
+              mitamagic::type_list<typename Units::system_type...>
+            >
+          >,
+          mitamagic::type_list<system<>>,
+          mitamagic::tlist_remove_if_t<is_wildcard,
+            mitamagic::type_list<typename Units::system_type...>
+          >
+        >
+      >;
 };
 
 template <class... Units>
diff --git a/include/mitama/dimensional/dimensional_traits.hpp b/include/mitama/dimensional/dimensional_traits.hpp
index 633bf577..bc71a194 100644
--- a/include/mitama/dimensional/dimensional_traits.hpp
+++ b/include/mitama/dimensional/dimensional_traits.hpp
@@ -157,7 +157,7 @@ namespace mitamagic {
     template <class From, class To>
     struct is_dimensional_convertible
         : std::conjunction<
-            is_complete_type<converter<std::decay_t<From>, std::decay_t<To>>>,
+            dimensional_ext::is_complete_type<converter<std::decay_t<From>, std::decay_t<To>>>,
             is_same_dimensional<std::decay_t<From>, std::decay_t<To>>>
     {};
 
diff --git a/include/mitama/dimensional/expr.hpp b/include/mitama/dimensional/expr.hpp
deleted file mode 100644
index 60d16771..00000000
--- a/include/mitama/dimensional/expr.hpp
+++ /dev/null
@@ -1,186 +0,0 @@
-#ifndef MITAMA_DIMENSIONAL_EXPR_HPP
-#define MITAMA_DIMENSIONAL_EXPR_HPP
-#include <mitama/dimensional/fwd/expr_fwd.hpp>
-#include <mitama/dimensional/quantity.hpp>
-#include <mitama/dimensional/arithmetic.hpp>
-#include <mitama/dimensional/systems/nonsi/degree_celsius.hpp>
-#include <mitama/dimensional/mitamagic/utility_ext.hpp>
-#include <type_traits>
-#include <utility>
-
-namespace mitama
-{
-
-struct expr_tag{};
-
-template <class T>
-inline constexpr bool is_expr_v = std::is_base_of_v<expr_tag, T>;
-
-
-template < class T > struct lexical_converter;
-
-template <template <class> class Synonym, class T, class Head, class... Tail >
-struct lexical_converter<quantity_t<Synonym<dimensional_t<Head, Tail...>>, T>>
-{
-  template < class Quantity >
-  static constexpr auto convert(Quantity&& value) {
-    if constexpr (is_complete_type_v<converter<std::decay_t<Quantity>, quantity_t<Synonym<dimensional_t<Head>>, T>>>)
-    {
-      return quantity_t<Synonym<dimensional_t<Head>>, T>{
-          converter<std::decay_t<Quantity>, quantity_t<Synonym<dimensional_t<Head>>, T>>::convert(value)};
-    }
-    else
-    {
-      return lexical_converter<quantity_t<Synonym<dimensional_t<Tail...>>, T>>::convert(value);
-    }
-  }
-};
-
-template < template <class> class Synonym, class T, class Head >
-struct lexical_converter<quantity_t<Synonym<dimensional_t<Head>>, T>>
-{
-  template < class Quantity >
-  static constexpr auto convert(Quantity&& value) {
-    if constexpr (is_complete_type_v<converter<std::decay_t<Quantity>, quantity_t<Synonym<dimensional_t<Head>>, T>>>)
-    {
-      return quantity_t<Synonym<dimensional_t<Head>>, T>{
-          converter<std::decay_t<Quantity>, quantity_t<Synonym<dimensional_t<Head>>, T>>::convert(value)};
-    }
-    else
-    {
-      return value;
-    }
-  }
-};
-
-
-template <class Quantity>
-struct quantity_wrapper : private expr_tag
-{
-  Quantity value_;
-  constexpr quantity_wrapper(Quantity value) : value_(value) {}
-  constexpr Quantity eval() const { return value_; }
-  template < class To >
-  constexpr auto lexical_evaluate() const { return lexical_converter<To>::template convert(value_); }
-};
-
-template < class T > quantity_wrapper(T&&) -> quantity_wrapper<std::decay_t<T>>;
-
-template < class T >
-inline constexpr auto as_expr(T&& t) {
-  if constexpr (is_expr_v<std::decay_t<T>>) {
-    return std::forward<T>(t);
-  }
-  else {
-    return quantity_wrapper{std::forward<T>(t)};
-  }
-}
-
-template < class T >
-using as_expr_t = std::decay_t<decltype(as_expr(std::declval<T>()))>;
-
-
-template <class BinaryOperator, class L, class R>
-class LexicalExpression : private expr_tag
-{
-  L lhs_;
-  R rhs_;
-public:
-  constexpr LexicalExpression(L const& lhs, R const& rhs): lhs_(lhs), rhs_(rhs) {}
-
-  template < class To >
-  auto lexical_evaluate() const {
-    return BinaryOperator::apply(lhs_.template lexical_evaluate<To>(), rhs_.template lexical_evaluate<To>());
-  }
-
-  constexpr auto eval() const
-  {
-    return BinaryOperator::apply(lhs_.eval(), rhs_.eval());
-  }
-
-  template <class Target,
-      std::enable_if_t<std::conjunction_v<
-        is_quantity<Target>
-      >, bool> = false>
-  constexpr operator Target() const { return {this->lexical_evaluate<Target>()}; }
-
-};
-
-template <class Quantity, class Expr>
-inline constexpr std::enable_if_t<is_expr_v<Expr>, Quantity&>
-operator|=(Quantity& quantity, Expr const& expr) {
-  quantity = expr.eval();
-  return quantity;
-}
-
-} // namespace mitama
-
-namespace mitama::operators
-{
-struct Add_
-{
-  template <typename L, typename R>
-  static constexpr auto apply(L const &lhs, R const &rhs)
-  {
-    return lhs + rhs;
-  }
-};
-
-struct Sub_
-{
-  template <typename L, typename R>
-  static constexpr auto apply(L const &lhs, R const &rhs)
-  {
-    return lhs - rhs;
-  }
-};
-
-struct Mul_
-{
-  template <typename L, typename R>
-  static constexpr auto apply(L const &lhs, R const &rhs)
-  {
-    return lhs * rhs;
-  }
-};
-
-struct Div_
-{
-  template <typename L, typename R>
-  static constexpr auto apply(L const &lhs, R const &rhs)
-  {
-    return lhs / rhs;
-  }
-};
-
-} // namespace mitama::operators
-
-namespace mitama
-{
-template <class L, class R, std::enable_if_t<is_expr_v<std::decay_t<L>> || is_expr_v<std::decay_t<R>>, bool> = false>
-inline constexpr LexicalExpression<operators::Add_, as_expr_t<L>, as_expr_t<R>>
-operator+(L const & lhs, R const & rhs)
-{
-  return {as_expr(lhs), as_expr(rhs)};
-}
-template <class L, class R, std::enable_if_t<is_expr_v<std::decay_t<L>> || is_expr_v<std::decay_t<R>>, bool> = false>
-inline constexpr LexicalExpression<operators::Sub_, as_expr_t<L>, as_expr_t<R>>
-operator-(L const & lhs, R const & rhs)
-{
-  return {as_expr(lhs), as_expr(rhs)};
-}
-template <class L, class R, std::enable_if_t<is_expr_v<std::decay_t<L>> || is_expr_v<std::decay_t<R>>, bool> = false>
-inline constexpr LexicalExpression<operators::Mul_, as_expr_t<L>, as_expr_t<R>>
-operator*(L const & lhs, R const & rhs)
-{
-  return {as_expr(lhs), as_expr(rhs)};
-}
-template <class L, class R, std::enable_if_t<is_expr_v<std::decay_t<L>> || is_expr_v<std::decay_t<R>>, bool> = false>
-inline constexpr LexicalExpression<operators::Div_, as_expr_t<L>, as_expr_t<R>>
-operator/(L const & lhs, R const & rhs)
-{
-  return {as_expr(lhs), as_expr(rhs)};
-}
-} // namespace mitama
-
-#endif
\ No newline at end of file
diff --git a/include/mitama/dimensional/io.hpp b/include/mitama/dimensional/io.hpp
index ef5ce88b..87ea75fd 100644
--- a/include/mitama/dimensional/io.hpp
+++ b/include/mitama/dimensional/io.hpp
@@ -70,8 +70,8 @@ template <class, class = void> struct si_formatter;
 template <int I, class D, class E, class S, class Sys>
 struct si_formatter<
     units_t<I, D, E, S, Sys>,
-    std::enable_if_t<std::conjunction_v<is_complete_type<prefix_<S>>,
-                                        is_complete_type<symbol_<D, I>>>>> {
+    std::enable_if_t<std::conjunction_v<dimensional_ext::is_complete_type<prefix_<S>>,
+                                        dimensional_ext::is_complete_type<symbol_<D, I>>>>> {
   static std::string format() {
     using namespace std::literals;
     using scale = std::conditional_t<std::is_same_v<D, ::mitama::systems::si::mass>,
@@ -86,7 +86,7 @@ struct si_formatter<
 namespace _detail {
 template <template <class> class Synonym, class T, class Head, class... Tail, class S>
 std::string
-abbreviation(quantity_t<Synonym<dimensional_t<Head, Tail...>>, T, S> const &quantity) {
+abbreviation(quantity_t<Synonym<dimensional_t<Head, Tail...>>, T, S> const &) {
   using namespace std::literals;
   return "[" + si_formatter<Head>::format() +
          ((" "s + si_formatter<Tail>::format()) + ... + "]");
@@ -94,7 +94,7 @@ abbreviation(quantity_t<Synonym<dimensional_t<Head, Tail...>>, T, S> const &quan
 
 template <template <class> class Synonym, class T, class S>
 std::string
-abbreviation(quantity_t<Synonym<dimensional_t<>>, T, S> const &quantity) {
+abbreviation(quantity_t<Synonym<dimensional_t<>>, T, S> const &) {
   return "[dimensionless]";
 }
 }
@@ -103,11 +103,11 @@ template <template <class> class Synonym, class T, class... Units, class S>
 std::string
 abbreviation(quantity_t<Synonym<dimensional_t<Units...>>, T, S> const &quantity) {
   using namespace std::literals::string_literals;
-  if constexpr (is_complete_type<
+  if constexpr (dimensional_ext::is_complete_type<
                             abbreviation_<Synonym<dimensional_t<Units...>>>>::value) {
     return "["s +  abbreviation_<Synonym<dimensional_t<Units...>>>::str << "]";
   } else if constexpr (std::conjunction_v<
-                    is_complete_type<prefix_<typename Units::scale>>...>) {
+                    dimensional_ext::is_complete_type<prefix_<typename Units::scale>>...>) {
     return "["s + mitama::_detail::abbreviation(quantity) + "]";
   } else {
     static_assert([]{ return false; }(), "error: abbreviation is not available");
@@ -119,9 +119,9 @@ std::ostream &
 operator<<(std::ostream &os,
            quantity_t<Synonym<dimensional_t<Units...>>, T, S> const &quantity) {
   using namespace std::literals::string_literals;
-  if constexpr (is_complete_type<abbreviation_<Synonym<dimensional_t<Units...>>>>::value) {
+  if constexpr (dimensional_ext::is_complete_type<abbreviation_<Synonym<dimensional_t<Units...>>>>::value) {
     return os << quantity.value() << " [" <<  abbreviation_<Synonym<dimensional_t<Units...>>>::str << "]";
-  } else if constexpr (std::conjunction_v<is_complete_type<prefix_<typename Units::scale>>...>) {
+  } else if constexpr (std::conjunction_v<dimensional_ext::is_complete_type<prefix_<typename Units::scale>>...>) {
     return os << quantity.value() << " " << mitama::_detail::abbreviation(quantity);
   } else {
     static_assert([]{ return false; }(), "error: abbreviation is not available");
diff --git a/include/mitama/dimensional/mitamagic/chars_to_decimal.hpp b/include/mitama/dimensional/mitamagic/chars_to_decimal.hpp
new file mode 100644
index 00000000..1c602f48
--- /dev/null
+++ b/include/mitama/dimensional/mitamagic/chars_to_decimal.hpp
@@ -0,0 +1,31 @@
+#ifndef MITAMA_DIMENSIONAL_MITAMAGIC_CHARS_TO_DECIMAL_HPP
+#define MITAMA_DIMENSIONAL_MITAMAGIC_CHARS_TO_DECIMAL_HPP
+#include <type_traits>
+#include <utility>
+
+namespace mitama::mitamagic {
+  template < std::size_t, class > struct Exp10;
+  template < std::size_t E, std::size_t... I >
+	struct Exp10<E, std::index_sequence<I...>> : std::integral_constant<std::size_t, E * (1 * ... * ((void)I,10))> {};
+	
+	template < char Head, char... Digits >
+	struct into_decimal
+		: std::integral_constant<
+        std::size_t,
+        Exp10<(Head - '0'), std::make_index_sequence<sizeof...(Digits)>>::value
+      + into_decimal<Digits...>::value >
+  {
+    static_assert(
+      ( ('0' <= Head && Head <= '9') && ... && ('0' <= Digits && Digits <= '9') ),
+      "Error");
+  };
+	
+	template < char Head >
+	struct into_decimal<Head>
+		: std::integral_constant<std::size_t, Head-'0'> {};
+
+  template < char... Digits >
+  inline constexpr std::size_t into_decimal_v = into_decimal<Digits...>::value;
+}
+
+#endif
\ No newline at end of file
diff --git a/include/mitama/dimensional/mitamagic/type_list.hpp b/include/mitama/dimensional/mitamagic/type_list.hpp
index f305c9f1..b79d3444 100644
--- a/include/mitama/dimensional/mitamagic/type_list.hpp
+++ b/include/mitama/dimensional/mitamagic/type_list.hpp
@@ -95,17 +95,6 @@ template <template <class> class Pred, class TypeList>
 inline constexpr bool tlist_all_match_if_v =
     tlist_all_match_if<Pred, TypeList>::value;
 
-template <template <class...> class, class> struct repack;
-
-template <template <class...> class Pack, template <class...> class _,
-          class... Elems>
-struct repack<Pack, _<Elems...>> {
-  using type = Pack<Elems...>;
-};
-
-template <template <class...> class P, class P_>
-using repack_t = typename repack<P, P_>::type;
-
 template <template <class> class, class, class> struct tlist_remove_if_impl;
 
 template <template <class> class Pred, template <class...> class tPack,
diff --git a/include/mitama/dimensional/mitamagic/type_traits_ext.hpp b/include/mitama/dimensional/mitamagic/type_traits_ext.hpp
index c4124132..5f417a17 100644
--- a/include/mitama/dimensional/mitamagic/type_traits_ext.hpp
+++ b/include/mitama/dimensional/mitamagic/type_traits_ext.hpp
@@ -3,7 +3,7 @@
 #include <type_traits>
 #include <utility>
 
-namespace mitama {
+namespace mitama::dimensional_ext {
 
 template < class T > struct identity: T { using type = T; };
 template < class T > using identity_t = typename identity<T>::type;
diff --git a/include/mitama/dimensional/quantity.hpp b/include/mitama/dimensional/quantity.hpp
index 862b7bde..24d9ab55 100644
--- a/include/mitama/dimensional/quantity.hpp
+++ b/include/mitama/dimensional/quantity.hpp
@@ -44,7 +44,7 @@ class Into<quantity_t<Synonym<dimensional_t<Units...>>, T, system<B...>>> {
 template < class To, class From >
 inline constexpr std::enable_if_t<is_dimensional_convertible_v<From, To>, To>
 dimensional_convert(From const& from) {
-  if constexpr (is_complete_type_v<converter<From, To>>){
+  if constexpr (dimensional_ext::is_complete_type_v<converter<From, To>>){
     return To{::mitama::converter<From, To>::convert(from)};
   }
   else {
@@ -139,7 +139,7 @@ class quantity_t<Synonym<dimensional_t<Units...>>, T, system<B...>>
 
   template <
       class D, class U, class S,
-      std::enable_if_t<is_complete_type_v<::mitama::converter<quantity_t<D, U, S>, quantity_t>> &&
+      std::enable_if_t<dimensional_ext::is_complete_type_v<::mitama::converter<quantity_t<D, U, S>, quantity_t>> &&
                            std::is_constructible_v<T, U> &&
                            std::is_convertible_v<U, T>,
                        bool> = false>
@@ -148,7 +148,7 @@ class quantity_t<Synonym<dimensional_t<Units...>>, T, system<B...>>
 
   template <
       class D, class U, class S,
-      std::enable_if_t<is_complete_type_v<::mitama::converter<quantity_t<D, U, S>, quantity_t>> &&
+      std::enable_if_t<dimensional_ext::is_complete_type_v<::mitama::converter<quantity_t<D, U, S>, quantity_t>> &&
                            std::is_constructible_v<T, U> &&
                            !std::is_convertible_v<U, T>,
                        bool> = false>
@@ -167,7 +167,7 @@ class quantity_t<Synonym<dimensional_t<Units...>>, T, system<B...>>
 
   template <
       class D, class U, class S,
-      std::enable_if_t<is_complete_type_v<::mitama::converter<quantity_t<D, U, S>, quantity_t>> &&
+      std::enable_if_t<dimensional_ext::is_complete_type_v<::mitama::converter<quantity_t<D, U, S>, quantity_t>> &&
                            std::is_convertible_v<U, T>,
                        bool> = false>
   constexpr quantity_t &operator=(quantity_t<D, U, S> const &o) & {
@@ -190,10 +190,10 @@ class quantity_t<Synonym<dimensional_t<Units...>>, T, system<B...>>
       class D, class U,
       std::enable_if_t<
         std::conjunction_v<
-          is_complete_type<::mitama::converter<quantity_t<D, U>, quantity_t>>,
-          is_equal_comparable_with<T, U>>
+          dimensional_ext::is_complete_type<::mitama::converter<quantity_t<D, U, system_type>, quantity_t>>,
+          dimensional_ext::is_greater_or_equal_comparable_with<T, U>>
         , bool> = false>
-  constexpr bool operator==(quantity_t<D, U> const &o) const {
+  constexpr bool operator==(quantity_t<D, U, system_type> const &o) const {
     return this->value_ == ::mitama::converter<quantity_t<D, U>, quantity_t>::convert(o);
   }
 
@@ -201,10 +201,10 @@ class quantity_t<Synonym<dimensional_t<Units...>>, T, system<B...>>
       class D, class U,
       std::enable_if_t<
         std::conjunction_v<
-          is_same_dimensional<quantity_t, quantity_t<D, U>>,
-          is_equal_comparable_with<T, U>>
+          is_same_dimensional<quantity_t, quantity_t<D, U, system_type>>,
+          dimensional_ext::is_greater_or_equal_comparable_with<T, U>>
         , bool> = false>
-  constexpr bool operator==(quantity_t<D, U> const &o) const {
+  constexpr bool operator==(quantity_t<D, U, system_type> const &o) const {
     auto [l, r] = mitamagic::scaler<dimension_type, typename quantity_t<D, U>::dimension_type>::template value<std::common_type_t<T, U>>();
     return l * this->value() == r * o.value();
   }
@@ -213,10 +213,10 @@ class quantity_t<Synonym<dimensional_t<Units...>>, T, system<B...>>
       class D, class U,
       std::enable_if_t<
         std::conjunction_v<
-          is_complete_type<::mitama::converter<quantity_t<D, U>, quantity_t>>,
-          is_notequal_comparable_with<T, U>>
+          dimensional_ext::is_complete_type<::mitama::converter<quantity_t<D, U, system_type>, quantity_t>>,
+          dimensional_ext::is_notequal_comparable_with<T, U>>
         , bool> = false>
-  constexpr bool operator!=(quantity_t<D, U> const &o) const {
+  constexpr bool operator!=(quantity_t<D, U, system_type> const &o) const {
     return this->value_ != ::mitama::converter<quantity_t<D, U>, quantity_t>::convert(o);
   }
 
@@ -224,10 +224,10 @@ class quantity_t<Synonym<dimensional_t<Units...>>, T, system<B...>>
       class D, class U,
       std::enable_if_t<
         std::conjunction_v<
-          is_same_dimensional<quantity_t, quantity_t<D, U>>,
-          is_notequal_comparable_with<T, U>>
+          is_same_dimensional<quantity_t, quantity_t<D, U, system_type>>,
+          dimensional_ext::is_notequal_comparable_with<T, U>>
         , bool> = false>
-  constexpr bool operator!=(quantity_t<D, U> const &o) const {
+  constexpr bool operator!=(quantity_t<D, U, system_type> const &o) const {
     auto [l, r] = mitamagic::scaler<dimension_type, typename quantity_t<D, U>::dimension_type>::template value<std::common_type_t<T, U>>();
     return l * this->value() != r * o.value();
   }
@@ -236,10 +236,10 @@ class quantity_t<Synonym<dimensional_t<Units...>>, T, system<B...>>
       class D, class U,
       std::enable_if_t<
         std::conjunction_v<
-          is_complete_type<::mitama::converter<quantity_t<D, U>, quantity_t>>,
-          is_less_comparable_with<T, U>>
+          dimensional_ext::is_complete_type<::mitama::converter<quantity_t<D, U, system_type>, quantity_t>>,
+          dimensional_ext::is_less_comparable_with<T, U>>
         , bool> = false>
-  constexpr bool operator<(quantity_t<D, U> const &o) const {
+  constexpr bool operator<(quantity_t<D, U, system_type> const &o) const {
     return this->value_ < ::mitama::converter<quantity_t<D, U>, quantity_t>::convert(o);
   }
 
@@ -247,10 +247,10 @@ class quantity_t<Synonym<dimensional_t<Units...>>, T, system<B...>>
       class D, class U,
       std::enable_if_t<
         std::conjunction_v<
-          is_same_dimensional<quantity_t, quantity_t<D, U>>,
-          is_less_comparable_with<T, U>>
+          is_same_dimensional<quantity_t, quantity_t<D, U, system_type>>,
+          dimensional_ext::is_less_comparable_with<T, U>>
         , bool> = false>
-  constexpr bool operator<(quantity_t<D, U> const &o) const {
+  constexpr bool operator<(quantity_t<D, U, system_type> const &o) const {
     auto [l, r] = mitamagic::scaler<dimension_type, typename quantity_t<D, U>::dimension_type>::template value<std::common_type_t<T, U>>();
     return l * this->value() < r * o.value();
   }
@@ -259,10 +259,10 @@ class quantity_t<Synonym<dimensional_t<Units...>>, T, system<B...>>
       class D, class U,
       std::enable_if_t<
         std::conjunction_v<
-          is_complete_type<::mitama::converter<quantity_t<D, U>, quantity_t>>,
-          is_less_or_equal_comparable_with<T, U>>
+          dimensional_ext::is_complete_type<::mitama::converter<quantity_t<D, U, system_type>, quantity_t>>,
+          dimensional_ext::is_less_or_equal_comparable_with<T, U>>
         , bool> = false>
-  constexpr bool operator<=(quantity_t<D, U> const &o) const {
+  constexpr bool operator<=(quantity_t<D, U, system_type> const &o) const {
     return this->value_ <= ::mitama::converter<quantity_t<D, U>, quantity_t>::convert(o);
   }
 
@@ -270,10 +270,10 @@ class quantity_t<Synonym<dimensional_t<Units...>>, T, system<B...>>
       class D, class U,
       std::enable_if_t<
         std::conjunction_v<
-          is_same_dimensional<quantity_t, quantity_t<D, U>>,
-          is_less_or_equal_comparable_with<T, U>>
+          is_same_dimensional<quantity_t, quantity_t<D, U, system_type>>,
+          dimensional_ext::is_less_or_equal_comparable_with<T, U>>
         , bool> = false>
-  constexpr bool operator<=(quantity_t<D, U> const &o) const {
+  constexpr bool operator<=(quantity_t<D, U, system_type> const &o) const {
     auto [l, r] = mitamagic::scaler<dimension_type, typename quantity_t<D, U>::dimension_type>::template value<std::common_type_t<T, U>>();
     return l * this->value() <= r * o.value();
   }
@@ -282,10 +282,10 @@ class quantity_t<Synonym<dimensional_t<Units...>>, T, system<B...>>
       class D, class U,
       std::enable_if_t<
         std::conjunction_v<
-          is_complete_type<::mitama::converter<quantity_t<D, U>, quantity_t>>,
-          is_greater_comparable_with<T, U>>
+          dimensional_ext::is_complete_type<::mitama::converter<quantity_t<D, U, system_type>, quantity_t>>,
+          dimensional_ext::is_greater_comparable_with<T, U>>
         , bool> = false>
-  constexpr bool operator>(quantity_t<D, U> const &o) const {
+  constexpr bool operator>(quantity_t<D, U, system_type> const &o) const {
     return this->value_ > ::mitama::converter<quantity_t<D, U>, quantity_t>::convert(o);
   }
 
@@ -293,10 +293,10 @@ class quantity_t<Synonym<dimensional_t<Units...>>, T, system<B...>>
       class D, class U,
       std::enable_if_t<
         std::conjunction_v<
-          is_same_dimensional<quantity_t, quantity_t<D, U>>,
-          is_greater_comparable_with<T, U>>
+          is_same_dimensional<quantity_t, quantity_t<D, U, system_type>>,
+          dimensional_ext::is_greater_comparable_with<T, U>>
         , bool> = false>
-  constexpr bool operator>(quantity_t<D, U> const &o) const {
+  constexpr bool operator>(quantity_t<D, U, system_type> const &o) const {
     auto [l, r] = mitamagic::scaler<dimension_type, typename quantity_t<D, U>::dimension_type>::template value<std::common_type_t<T, U>>();
     return l * this->value() > r * o.value();
   }
@@ -305,10 +305,10 @@ class quantity_t<Synonym<dimensional_t<Units...>>, T, system<B...>>
       class D, class U,
       std::enable_if_t<
         std::conjunction_v<
-          is_complete_type<::mitama::converter<quantity_t<D, U>, quantity_t>>,
-          is_greater_or_equal_comparable_with<T, U>>
+          dimensional_ext::is_complete_type<::mitama::converter<quantity_t<D, U, system_type>, quantity_t>>,
+          dimensional_ext::is_greater_or_equal_comparable_with<T, U>>
         , bool> = false>
-  constexpr bool operator>=(quantity_t<D, U> const &o) const {
+  constexpr bool operator>=(quantity_t<D, U, system_type> const &o) const {
     return this->value_ >= ::mitama::converter<quantity_t<D, U>, quantity_t>::convert(o);
   }
 
@@ -316,10 +316,10 @@ class quantity_t<Synonym<dimensional_t<Units...>>, T, system<B...>>
       class D, class U,
       std::enable_if_t<
         std::conjunction_v<
-          is_same_dimensional<quantity_t, quantity_t<D, U>>,
-          is_greater_or_equal_comparable_with<T, U>>
+          is_same_dimensional<quantity_t, quantity_t<D, U, system_type>>,
+          dimensional_ext::is_greater_or_equal_comparable_with<T, U>>
         , bool> = false>
-  constexpr bool operator>=(quantity_t<D, U> const &o) const {
+  constexpr bool operator>=(quantity_t<D, U, system_type> const &o) const {
     auto [l, r] = mitamagic::scaler<dimension_type, typename quantity_t<D, U>::dimension_type>::template value<std::common_type_t<T, U>>();
     return l * this->value() >= r * o.value();
   }
@@ -395,9 +395,12 @@ operator/(U1, U2) {
   return {};
 }
 
-template <class Dim, class T>
-constexpr std::enable_if_t<is_dimensional_quantifier<Dim>::value, quantity_t<Dim, std::decay_t<T>>>
-operator|(T &&t, Dim) {
+template <template <class> class Syn, class Dim, class T>
+constexpr
+std::enable_if_t<
+  is_dimensional_quantifier<Syn<Dim>>::value,
+  quantity_t<Syn<Dim>, std::decay_t<T>, typename Dim::system_type>>
+operator|(T &&t, Syn<Dim>) {
   return { mitama::decay_copy(std::forward<T>(t)) };
 }
 
diff --git a/include/mitama/dimensional/refinement.hpp b/include/mitama/dimensional/refinement.hpp
deleted file mode 100644
index df95af68..00000000
--- a/include/mitama/dimensional/refinement.hpp
+++ /dev/null
@@ -1,255 +0,0 @@
-#ifndef MITAMA_DIMENSIONAL_REFINEMENT_HPP
-#define MITAMA_DIMENSIONAL_REFINEMENT_HPP
-#include <mitama/dimensional/quantity.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/mitamagic/type_list.hpp>
-#include <type_traits>
-
-namespace mitama {
-
-namespace sym {
-class refinement_symbol_tag {};
-
-template <std::intmax_t N = 1> struct L : private refinement_symbol_tag {
-  using basis = ::mitama::systems::si::length;
-  using exp = std::ratio<N>;
-};
-template <std::intmax_t N = 1> struct M : private refinement_symbol_tag {
-  using basis = ::mitama::systems::si::mass;
-  using exp = std::ratio<N>;
-};
-template <std::intmax_t N = 1> struct T : private refinement_symbol_tag {
-  using basis = ::mitama::systems::si::time;
-  using exp = std::ratio<N>;
-};
-template <std::intmax_t N = 1> struct I : private refinement_symbol_tag {
-  using basis = ::mitama::systems::si::electric_current;
-  using exp = std::ratio<N>;
-};
-template <std::intmax_t N = 1> struct S : private refinement_symbol_tag {
-  using basis = ::mitama::systems::si::thermodynamic_temperature;
-  using exp = std::ratio<N>;
-};
-template <std::intmax_t E = 1> struct N : private refinement_symbol_tag {
-  using basis = ::mitama::systems::si::amount_of_substance;
-  using exp = std::ratio<E>;
-};
-template <std::intmax_t N = 1> struct J : private refinement_symbol_tag {
-  using basis = ::mitama::systems::si::luminous_intensity;
-  using exp = std::ratio<N>;
-};
-
-template <class T>
-using is_refinement_symbol = std::is_base_of<refinement_symbol_tag, T>;
-template <class T>
-inline constexpr bool is_refinement_symbol_v = is_refinement_symbol<T>::value;
-
-} // namespace sym
-
-template <class, template <class> class, class> struct refinement_type;
-template <class, template <class> class, class...> struct refinement_type_for;
-
-template <template <class> class Pred, class... Symbols>
-struct refinement_type_for<
-    std::enable_if_t<std::conjunction_v<sym::is_refinement_symbol<Symbols>...>>,
-    Pred, Symbols...> {
-  template <class Q,
-            std::enable_if_t<
-                Pred<is_same_dimensional<
-                     std::decay_t<Q>,
-                     quantity_t<make_dimensional_t<units_t<0,
-                         typename Symbols::basis, typename Symbols::exp>...>>>>::value,
-                bool> = false>
-  constexpr decltype(auto) operator()(Q &&q) const {
-    return std::forward<Q>(q);
-  }
-
-  decltype(auto) operator()(...) const = delete;
-
-  template <class Q,
-            std::enable_if_t<
-                Pred<is_same_dimensional<
-                     std::decay_t<Q>,
-                     quantity_t<make_dimensional_t<units_t<0,
-                         typename Symbols::basis, typename Symbols::exp>...>>>>::value,
-                bool> = false>
-  constexpr decltype(auto) operator|=(Q &&q) const {
-    return std::forward<Q>(q);
-  }
-
-  template < class... Args >
-  decltype(auto) operator|=(Args&&...) const = delete;
-};
-
-template <template <class> class Pred, template <class...> class Requires, class... Symbols>
-struct refinement_type<
-    std::enable_if_t<std::conjunction_v<sym::is_refinement_symbol<Symbols>...>>,
-    Pred, Requires<Symbols...>> {
-  template <class Q,
-            std::enable_if_t<
-                Pred<is_same_dimensional<
-                     std::decay_t<Q>,
-                     quantity_t<make_dimensional_t<units_t<0,
-                         typename Symbols::basis, typename Symbols::exp>...>>>>::value,
-                bool> = false>
-  constexpr decltype(auto) operator()(Q &&q) const {
-    return std::forward<Q>(q);
-  }
-
-  decltype(auto) operator()(...) const = delete;
-
-  template <class Q,
-            std::enable_if_t<
-                Pred<is_same_dimensional<
-                     std::decay_t<Q>,
-                     quantity_t<make_dimensional_t<units_t<0,
-                         typename Symbols::basis, typename Symbols::exp>...>>>>::value,
-                bool> = false>
-  constexpr decltype(auto) operator|=(Q &&q) const {
-    return std::forward<Q>(q);
-  }
-
-  template <class... Dummy>
-  decltype(auto) operator|=(Dummy&&...) const = delete;
-};
-
-template <class... Requires>
-inline constexpr refinement_type_for<void, identity, Requires...> accepts_for{};
-
-template <class Requires>
-inline constexpr refinement_type<void, identity, Requires> accepts{};
-
-template <class... Requires>
-inline constexpr refinement_type_for<void, std::negation, Requires...> rejects_for{};
-
-template <class Requires>
-inline constexpr refinement_type<void, std::negation, Requires> rejects{};
-
-
-template <class, template <class> class, class...> struct partial_refinement_type_for;
-template <class, template <class> class, class> struct partial_refinement_type;
-
-template <template <class> class Pred, class... Symbols>
-struct partial_refinement_type_for<
-	std::enable_if_t<std::conjunction_v<sym::is_refinement_symbol<Symbols>...>>,
-	Pred, Symbols...> {
-
-  template <class Q,
-            std::enable_if_t<
-              Pred<std::conjunction<
-                std::is_base_of<
-                  dimension_tag<0, typename Symbols::basis, typename Symbols::exp>,
-                  typename std::decay_t<Q>::dimension_type
-                >...
-              >>::value,
-            bool> = false>
-  constexpr decltype(auto) operator()(Q &&q) const {
-    return std::forward<Q>(q);
-  }
-
-  decltype(auto) operator()(...) const = delete;
-
-  template <class Q,
-            std::enable_if_t<
-              Pred<std::conjunction<
-                std::is_base_of<
-                  dimension_tag<0, typename Symbols::basis, typename Symbols::exp>,
-                  typename std::decay_t<Q>::dimension_type
-                >...
-              >>::value,
-            bool> = false>
-  constexpr decltype(auto) operator|=(Q &&q) const {
-    return std::forward<Q>(q);
-  }
-
-  template <class... Dummy>
-  decltype(auto) operator|=(Dummy&&...) const = delete;
-};
-
-template <template <class> class Pred, template <class...> class Requires, class... Symbols>
-struct partial_refinement_type<
-	std::enable_if_t<std::conjunction_v<sym::is_refinement_symbol<Symbols>...>>,
-	Pred, Requires<Symbols...>> {
-
-  template <class Q,
-            std::enable_if_t<
-              Pred<std::conjunction<
-                std::is_base_of<
-                  dimension_tag<0, typename Symbols::basis, typename Symbols::exp>,
-                  typename std::decay_t<Q>::dimension_type
-                >...
-              >>::value,
-            bool> = false>
-  constexpr decltype(auto) operator()(Q &&q) const {
-    return std::forward<Q>(q);
-  }
-
-  decltype(auto) operator()(...) const = delete;
-
-  template <class Q,
-            std::enable_if_t<
-              Pred<std::conjunction<
-                std::is_base_of<
-                  dimension_tag<0, typename Symbols::basis, typename Symbols::exp>,
-                  typename std::decay_t<Q>::dimension_type
-                >...
-              >>::value,
-            bool> = false>
-  constexpr decltype(auto) operator|=(Q &&q) const {
-    return std::forward<Q>(q);
-  }
-
-  template <class... Dummy>
-  decltype(auto) operator|=(Dummy&&...) const = delete;
-};
-
-template <class... Requires>
-inline constexpr partial_refinement_type_for<void, identity, Requires...> partial_accepts_for{};
-
-template <class Requires>
-inline constexpr partial_refinement_type<void, identity, Requires> partial_accepts{};
-
-template <class... Requires>
-inline constexpr partial_refinement_type_for<void, std::negation, Requires...> partial_rejects_for{};
-
-template <class Requires>
-inline constexpr partial_refinement_type<void, std::negation, Requires> partial_rejects{};
-} // namespace mitama
-
-namespace mitama {
-using length_r = mitamagic::type_list<sym::L<1>>;
-using mass_r = mitamagic::type_list<sym::M<1>>;
-using time_r = mitamagic::type_list<sym::T<1>>;
-using current_r = mitamagic::type_list<sym::I<1>>;
-using thermo_r = mitamagic::type_list<sym::S<1>>;
-using amount_r = mitamagic::type_list<sym::N<1>>;
-using luminous_r = mitamagic::type_list<sym::J<1>>;
-} // namespace mitama
-
-namespace mitama {
-namespace mitamagic {
-
-template < class Unit >
-struct atomic_refinement_symbol
-  : ::mitama::sym::refinement_symbol_tag
-{
-  using basis = typename Unit::dimension_type;
-  using exp   = typename Unit::exponent;
-};
-} // ! namespace mitamagic
-
-
-template < class > struct make_refinement_symbol;
-
-template < template <class> class Synonym, class... Units >
-struct make_refinement_symbol<Synonym<dimensional_t<Units...>>>
-{
-  using type = mitamagic::type_list<mitamagic::atomic_refinement_symbol<Units>...>;
-};
-
-template < class T >
-using make_refinement_symbol_t = typename make_refinement_symbol<std::decay_t<T>>::type;
-
-} // ! namespace mitama
-
-#endif
diff --git a/include/mitama/dimensional/static_quantity.hpp b/include/mitama/dimensional/static_quantity.hpp
deleted file mode 100644
index 38840aca..00000000
--- a/include/mitama/dimensional/static_quantity.hpp
+++ /dev/null
@@ -1,326 +0,0 @@
-#ifndef MITAMA_DIMENSIONAL_STATIC_QUANTITY_HPP
-#define MITAMA_DIMENSIONAL_STATIC_QUANTITY_HPP
-#include <mitama/dimensional/fwd/quantity_fwd.hpp>
-#include <mitama/dimensional/mitamagic/quotient.hpp>
-#include <mitama/dimensional/mitamagic/ratio_ext.hpp>
-#include <mitama/dimensional/mitamagic/type_traits_ext.hpp>
-
-namespace mitama {
-
-    struct Add {
-        template < class T >
-        static constexpr auto invoke(T a, T b) { return a + b; }
-    };
-    struct Sub {
-        template < class T >
-        static constexpr auto invoke(T a, T b) { return a - b; }
-    };
-    struct Mul {
-        template < class T >
-        static constexpr auto invoke(T a, T b) { return a * b; }
-    };
-    struct Div {
-        template < class T >
-        static constexpr auto invoke(T a, T b) { return a / b; }
-    };
-    template < std::size_t N >
-    struct Pow {
-        template < class T, std::size_t... Indices >
-        static constexpr auto impl(T a,std::index_sequence<Indices...>) {
-            return (((void)Indices, a) * ... * T{1});
-        } 
-
-        template < class T >
-        static constexpr auto invoke(T a) { return impl(a, std::make_index_sequence<N>{}); }
-    };
-
-
-    template < class... Units, template <class> class Synonym, auto Value >
-    struct static_quantity_t<Synonym<dimensional_t<Units...>>, Value>
-    {
-        using value_type = decltype(Value);
-        static constexpr value_type value = Value;
-
-        constexpr static_quantity_t<Synonym<dimensional_t<Units...>>, -Value>
-        operator-() const { return {}; }
-    };
-
-    template < class _, auto Value >
-    inline constexpr auto get(static_quantity_t<_, Value>) { return Value; }
-
-    template < class Dim, auto Value >
-    inline constexpr static_quantity_t<Dim, Value> static_quantity{};
-
-    template <class D1, class D2, class T, auto V1, auto V2, class F>
-    static constexpr auto make_scaled_value() {
-        auto [l, r] = mitama::mitamagic::scaler<D1, D2>::template value<T>();
-        return F::invoke(V1 * l, V2 * r);
-    }
-
-    template < class... Units1, template <class> class Synonym1, auto Value1,
-               class... Units2, template <class> class Synonym2, auto Value2,
-               std::enable_if_t<
-                   is_same_dimensional_v<
-                       dimensional_t<Units1...>,
-                       dimensional_t<Units2...>>,
-               bool> = false >
-    inline constexpr auto
-    operator+ (static_quantity_t<Synonym1<dimensional_t<Units1...>>, Value1>,
-               static_quantity_t<Synonym2<dimensional_t<Units2...>>, Value2>) noexcept
-        -> static_quantity_t<mitamagic::scaled_dimension_t<dimensional_t<Units1...>, dimensional_t<Units2...>>,
-                             make_scaled_value<dimensional_t<Units1...>,
-                                               dimensional_t<Units2...>,
-                                               std::common_type_t<decltype(Value1), decltype(Value2)>,
-                                               Value1, Value2, Add>()>
-        { return {}; }
-
-    template < class... Units1, template <class> class Synonym1, auto Value1,
-               class... Units2, template <class> class Synonym2, auto Value2,
-                   std::enable_if_t<
-                   is_same_dimensional_v<
-                       dimensional_t<Units1...>,
-                       dimensional_t<Units2...>>,
-               bool> = false >
-    inline constexpr auto
-    operator- (static_quantity_t<Synonym1<dimensional_t<Units1...>>, Value1>,
-               static_quantity_t<Synonym2<dimensional_t<Units2...>>, Value2>) noexcept
-        -> static_quantity_t<mitamagic::scaled_dimension_t<dimensional_t<Units1...>, dimensional_t<Units2...>>,
-                             make_scaled_value<dimensional_t<Units1...>,
-                                               dimensional_t<Units2...>,
-                                               std::common_type_t<decltype(Value1), decltype(Value2)>,
-                                               Value1, Value2, Sub>()>
-        { return {}; }
-
-    template < class... Units1, template <class> class Synonym1, auto Value1,
-               class... Units2, template <class> class Synonym2, auto Value2 >
-    inline constexpr auto
-    operator* (static_quantity_t<Synonym1<dimensional_t<Units1...>>, Value1>,
-               static_quantity_t<Synonym2<dimensional_t<Units2...>>, Value2>) noexcept
-        -> static_quantity_t<mitamagic::quotient_t<dimensional_t<Units1...>,
-                                                   dimensional_t<Units2...>>,
-                             make_scaled_value<dimensional_t<Units1...>,
-                                               dimensional_t<Units2...>,
-                                               std::common_type_t<decltype(Value1), decltype(Value2)>,
-                                               Value1, Value2, Mul>()>
-        { return {}; }
-
-    template < class... Units1, template <class> class Synonym1, auto Value1,
-               class... Units2, template <class> class Synonym2, auto Value2 >
-    inline constexpr auto
-    operator/ (static_quantity_t<Synonym1<dimensional_t<Units1...>>, Value1>,
-               static_quantity_t<Synonym2<dimensional_t<Units2...>>, Value2>) noexcept
-        -> static_quantity_t<mitamagic::quotient_t<dimensional_t<Units1...>,
-                                                   mitamagic::inverse_t<dimensional_t<Units2...>>>,
-                             make_scaled_value<dimensional_t<Units1...>,
-                                               dimensional_t<Units2...>,
-                                               std::common_type_t<decltype(Value1), decltype(Value2)>,
-                                               Value1, Value2, Div>()>
-        { return {}; }
-
-    template < std::size_t N,
-               class... Units, template <class> class Synonym, auto Value >
-    inline constexpr auto
-    pow(static_quantity_t<Synonym<dimensional_t<Units...>>, Value>) noexcept
-        -> static_quantity_t<powered_t<Synonym<dimensional_t<Units...>>, N>, Pow<N>::invoke(Value)>
-        { return {}; }
-
-    template < template < auto > class Pred, class Dim, class T > 
-    class refined<Pred, quantity_t<Dim, T>> {
-        quantity_t<Dim, T> quantity_;
-    public:
-        template < auto Value, class Dimension,
-            std::enable_if_t<std::conjunction_v<
-                std::is_constructible<
-                    quantity_t<Dim, T>,
-                    quantity_t<Dimension, decltype(Value)>>,
-                Pred<Value>>
-            , bool> = false>
-        constexpr refined(static_quantity_t<Dimension, Value>)
-            : quantity_(quantity_t<Dimension, decltype(Value)>(Value))
-        {}
-
-        constexpr auto get() const noexcept { return quantity_; }
-    };
-}
-
-namespace mitama::mitamagic {
-  template < std::size_t, class > struct Exp10;
-  template < std::size_t E, std::size_t... I >
-	struct Exp10<E, std::index_sequence<I...>> : std::integral_constant<std::size_t, E * (1 * ... * ((void)I,10))> {};
-	
-	template < char Head, char... Digits >
-	struct to_decimal
-		: std::integral_constant<
-        std::size_t,
-        Exp10<(Head - '0'), std::make_index_sequence<sizeof...(Digits)>>::value
-      + to_decimal<Digits...>::value >
-  {
-    static_assert(
-      ( ('0' <= Head && Head <= '9') && ... && ('0' <= Digits && Digits <= '9') ),
-      "Error");
-  };
-	
-	template < char Head >
-	struct to_decimal<Head>
-		: std::integral_constant<std::size_t, Head-'0'> {};
-
-  template < char... Digits >
-  inline constexpr std::size_t to_decimal_v = to_decimal<Digits...>::value;
-}
-
-#include <mitama/dimensional/systems/si/all.hpp>
-
-namespace mitama::literals {
-inline namespace static_quantity_literals {
-
-inline namespace length_literals {
-    template<char... Chars>
-    inline constexpr
-    static_quantity_t<
-        mitama::systems::si::meter_t,
-        static_cast<int>(mitamagic::to_decimal_v<Chars...>)> 
-    operator"" _m() { return {}; }
-
-    template<char... Chars>
-    inline constexpr
-    static_quantity_t<
-        mitama::systems::si::millimeter_t,
-        static_cast<int>(mitamagic::to_decimal_v<Chars...>)> 
-    operator"" _mm() { return {}; }
-
-    template<char... Chars>
-    inline constexpr
-    static_quantity_t<
-        mitama::systems::si::kilometer_t,
-        static_cast<int>(mitamagic::to_decimal_v<Chars...>)> 
-    operator"" _km() { return {}; }
-}
-
-inline namespace mass_literals {
-    template<char... Chars>
-    inline constexpr
-    static_quantity_t<
-        mitama::systems::si::milligram_t,
-        static_cast<int>(mitamagic::to_decimal_v<Chars...>)> 
-    operator"" _mg() { return {}; }
-
-    template<char... Chars>
-    inline constexpr
-    static_quantity_t<
-        mitama::systems::si::gram_t,
-        static_cast<int>(mitamagic::to_decimal_v<Chars...>)> 
-    operator"" _g() { return {}; }
-
-    template<char... Chars>
-    inline constexpr
-    static_quantity_t<
-        mitama::systems::si::kilogram_t,
-        static_cast<int>(mitamagic::to_decimal_v<Chars...>)> 
-    operator"" _kg() { return {}; }
-}
-
-inline namespace time_literals {
-    template<char... Chars>
-    inline constexpr
-    static_quantity_t<
-        mitama::systems::si::nanosecond_t,
-        static_cast<int>(mitamagic::to_decimal_v<Chars...>)> 
-    operator"" _ns() { return {};}
-
-    template<char... Chars>
-    inline constexpr
-    static_quantity_t<
-        mitama::systems::si::microsecond_t,
-        static_cast<int>(mitamagic::to_decimal_v<Chars...>)> 
-    operator"" _us() { return {}; }
-
-    template<char... Chars>
-    inline constexpr
-    static_quantity_t<
-        mitama::systems::si::millisecond_t,
-        static_cast<int>(mitamagic::to_decimal_v<Chars...>)> 
-    operator"" _ms() { return {}; }
-
-    template<char... Chars>
-    inline constexpr
-    static_quantity_t<
-        mitama::systems::si::second_t,
-        static_cast<int>(mitamagic::to_decimal_v<Chars...>)> 
-    operator"" _s() { return {}; }
-}
-
-inline namespace electric_current_literals {
-    template<char... Chars>
-    inline constexpr
-    static_quantity_t<
-        mitama::systems::si::milliampere_t,
-        static_cast<int>(mitamagic::to_decimal_v<Chars...>)> 
-    operator"" _mA() { return {};}
-
-    template<char... Chars>
-    inline constexpr
-    static_quantity_t<
-        mitama::systems::si::ampere_t,
-        static_cast<int>(mitamagic::to_decimal_v<Chars...>)> 
-    operator"" _A() { return {}; }
-
-    template<char... Chars>
-    inline constexpr
-    static_quantity_t<
-        mitama::systems::si::kiloampere_t,
-        static_cast<int>(mitamagic::to_decimal_v<Chars...>)> 
-    operator"" _kA() { return {}; }
-}
-
-inline namespace temperatire_literals {
-    template<char... Chars>
-    inline constexpr
-    static_quantity_t<
-        mitama::systems::si::millikelvin_t,
-        static_cast<int>(mitamagic::to_decimal_v<Chars...>)> 
-    operator"" _mK() { return {};}
-
-    template<char... Chars>
-    inline constexpr
-    static_quantity_t<
-        mitama::systems::si::kelvin_t,
-        static_cast<int>(mitamagic::to_decimal_v<Chars...>)> 
-    operator"" _K() { return {}; }
-}
-
-inline namespace amount_of_substance_literals {
-    template<char... Chars>
-    inline constexpr
-    static_quantity_t<
-        mitama::systems::si::millimol_t,
-        static_cast<int>(mitamagic::to_decimal_v<Chars...>)> 
-    operator"" _mmol() { return {};}
-
-    template<char... Chars>
-    inline constexpr
-    static_quantity_t<
-        mitama::systems::si::mol_t,
-        static_cast<int>(mitamagic::to_decimal_v<Chars...>)> 
-    operator"" _mol() { return {}; }
-
-    template<char... Chars>
-    inline constexpr
-    static_quantity_t<
-        mitama::systems::si::kilomol_t,
-        static_cast<int>(mitamagic::to_decimal_v<Chars...>)> 
-    operator"" _kmol() { return {}; }
-}
-
-inline namespace luminous_intensity_literals {
-    template<char... Chars>
-    inline constexpr
-    static_quantity_t<
-        mitama::systems::si::candela_t,
-        static_cast<int>(mitamagic::to_decimal_v<Chars...>)> 
-    operator"" _cd() { return {};}
-}
-
-
-}
-}
-#endif
diff --git a/include/mitama/dimensional/system.hpp b/include/mitama/dimensional/system.hpp
index 55fddf33..004aad80 100644
--- a/include/mitama/dimensional/system.hpp
+++ b/include/mitama/dimensional/system.hpp
@@ -16,6 +16,12 @@ namespace mitama {
   template < class, class >
   struct common_system;
 
+  template < class... Dim >
+  struct common_system<system<Dim...>, system<Dim...>>
+  {
+    using type = system<Dim...>;
+  };
+
   template < class... Dim >
   struct common_system<system<>, system<Dim...>>
   {
diff --git a/include/mitama/dimensional/systems/si/base_units/candela.hpp b/include/mitama/dimensional/systems/si/base_units/candela.hpp
index 63303393..c88ef897 100644
--- a/include/mitama/dimensional/systems/si/base_units/candela.hpp
+++ b/include/mitama/dimensional/systems/si/base_units/candela.hpp
@@ -7,11 +7,13 @@
 namespace mitama::systems::si {
 
 using candela_t = typename candela_base_unit::unit_type_with_system<::mitama::systems::si::system>;
+using millicandela_t = scaled_unit_t<candela_t, std::milli>;
 
 template < std::intmax_t N = 1 >
 using candela_ = powered_t<candela_t, N>;
 
 inline constexpr candela_t candelas{};
+inline constexpr millicandela_t millicandelas{};
 
 template < std::intmax_t N = 1 > inline constexpr powered_t<candela_t, N> candela{};
 
diff --git a/include/mitama/dimensional/systems/si/base_units/fwd/si_base_units.hpp b/include/mitama/dimensional/systems/si/base_units/fwd/si_base_units.hpp
index a24ad407..3636d4b5 100644
--- a/include/mitama/dimensional/systems/si/base_units/fwd/si_base_units.hpp
+++ b/include/mitama/dimensional/systems/si/base_units/fwd/si_base_units.hpp
@@ -7,6 +7,8 @@
 #include <mitama/dimensional/systems/si/base_dimension/length.hpp>
 #include <mitama/dimensional/systems/si/base_dimension/amount_of_substance.hpp>
 #include <mitama/dimensional/systems/si/base_dimension/time.hpp>
+#include <mitama/dimensional/systems/si/base_dimension/angle.hpp>
+#include <mitama/dimensional/systems/si/base_dimension/solid_angle.hpp>
 #include <mitama/dimensional/units.hpp>
 #include <mitama/dimensional/system.hpp>
 
@@ -19,6 +21,8 @@ using meter_base_unit = base_units<length, 0>;
 using metre_base_unit = base_units<length, 0>;
 using mole_base_unit = base_units<amount_of_substance, 0>;
 using second_base_unit = base_units<time, 0>;
+using angle_base_unit = base_units<angle, 0>;
+using solid_angle_base_unit = base_units<solid_angle, 0>;
 
 using system
     = ::mitama::system<
@@ -28,7 +32,9 @@ using system
         kilogram_base_unit,
         meter_base_unit,
         mole_base_unit,
-        second_base_unit
+        second_base_unit,
+        angle_base_unit,
+        solid_angle_base_unit
     >;
 }
 
diff --git a/include/mitama/dimensional/systems/si/derived_units/absorbed_dose.hpp b/include/mitama/dimensional/systems/si/derived_units/absorbed_dose.hpp
index 8c085a1c..ee5a2cec 100644
--- a/include/mitama/dimensional/systems/si/derived_units/absorbed_dose.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/absorbed_dose.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct absorbed_dose_synonym{};
 using absorbed_dose_t = make_synonym_t<absorbed_dose_synonym, decltype(meter<2> * second<-2>)>;
 
 inline constexpr absorbed_dose_t gray{};
-using absorbed_dose_r = make_refinement_symbol_t<absorbed_dose_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/absorbed_dose_rate.hpp b/include/mitama/dimensional/systems/si/derived_units/absorbed_dose_rate.hpp
index 3b013961..a3109de7 100644
--- a/include/mitama/dimensional/systems/si/derived_units/absorbed_dose_rate.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/absorbed_dose_rate.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "absorbed_dose.hpp"
 
 namespace mitama::systems::si {
@@ -12,7 +12,7 @@ template < class > struct absorbed_dose_rate_synonym{};
 using absorbed_dose_rate_t = make_synonym_t<absorbed_dose_rate_synonym, decltype(gray / second<>)>;
 
 inline constexpr absorbed_dose_rate_t absorbed_dose_rate{};
-using absorbed_dose_rate_r = make_refinement_symbol_t<absorbed_dose_rate_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/acceleration.hpp b/include/mitama/dimensional/systems/si/derived_units/acceleration.hpp
index a19b83d0..32acffe4 100644
--- a/include/mitama/dimensional/systems/si/derived_units/acceleration.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/acceleration.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct acceleration_synonym{};
 using acceleration_t = make_synonym_t<acceleration_synonym, decltype(meters * second<-2>)>;
 
 inline constexpr acceleration_t acceleration{};
-using acceleration_r = make_refinement_symbol_t<acceleration_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/action.hpp b/include/mitama/dimensional/systems/si/derived_units/action.hpp
index 68498fe6..15362a52 100644
--- a/include/mitama/dimensional/systems/si/derived_units/action.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/action.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct action_synonym{};
 using action_t = make_synonym_t<action_synonym, decltype(meter<2> * kilogram<> * second<-1>)>;
 
 inline constexpr action_t action{};
-using action_r = make_refinement_symbol_t<action_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/angle.hpp b/include/mitama/dimensional/systems/si/derived_units/angle.hpp
index 0f76d8ed..6c141195 100644
--- a/include/mitama/dimensional/systems/si/derived_units/angle.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/angle.hpp
@@ -3,13 +3,13 @@
 #include <mitama/dimensional/systems/si/base_dimension/angle.hpp>
 #include <mitama/dimensional/units.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 namespace mitama::systems::si {
 using radian_base_unit = base_units<angle, 0>;
 using radian_t = typename radian_base_unit::unit_type;
 inline constexpr radian_t radian{};
-using radian_r = make_refinement_symbol_t<radian_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/angular_acceleration.hpp b/include/mitama/dimensional/systems/si/derived_units/angular_acceleration.hpp
index 2fd62004..e1f79cb9 100644
--- a/include/mitama/dimensional/systems/si/derived_units/angular_acceleration.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/angular_acceleration.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "angle.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct angular_acceleration_synonym{};
 using angular_acceleration_t = make_synonym_t<angular_acceleration_synonym, decltype(radian / second<2>)>;
 
 inline constexpr angular_acceleration_t angular_acceleration{};
-using angular_acceleration_r = make_refinement_symbol_t<angular_acceleration_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/angular_momentum.hpp b/include/mitama/dimensional/systems/si/derived_units/angular_momentum.hpp
index 17d9c69b..b5e6d04d 100644
--- a/include/mitama/dimensional/systems/si/derived_units/angular_momentum.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/angular_momentum.hpp
@@ -3,14 +3,14 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 namespace mitama::systems::si {
 template<class> struct angular_momentum_synonym{};
 using angular_momentum_t = make_synonym_t<angular_momentum_synonym, decltype(meter<2> * kilogram<> * second<-1>)>;
 
 inline constexpr angular_momentum_t angular_momentum{};
-using angular_momentum_r = make_refinement_symbol_t<angular_momentum_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/angular_velocity.hpp b/include/mitama/dimensional/systems/si/derived_units/angular_velocity.hpp
index 87dff01a..151c2581 100644
--- a/include/mitama/dimensional/systems/si/derived_units/angular_velocity.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/angular_velocity.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "angle.hpp"
 
 
@@ -12,7 +12,7 @@ template<class> struct angular_velocity_synonym{};
 using angular_velocity_t = make_synonym_t<angular_velocity_synonym, decltype(radian / seconds)>;
 
 inline constexpr angular_velocity_t angular_velocity{};
-using angular_velocity_r = make_refinement_symbol_t<angular_velocity_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/area.hpp b/include/mitama/dimensional/systems/si/derived_units/area.hpp
index 223292dd..8a68c5c5 100644
--- a/include/mitama/dimensional/systems/si/derived_units/area.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/area.hpp
@@ -3,14 +3,14 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
 using area_t = powered_t<meter_t, 2>;
 
 inline constexpr area_t area{};
-using area_r = make_refinement_symbol_t<area_t>;
+
 }
 
 #endif
diff --git a/include/mitama/dimensional/systems/si/derived_units/area_density.hpp b/include/mitama/dimensional/systems/si/derived_units/area_density.hpp
index db2a41b3..1b2a8851 100644
--- a/include/mitama/dimensional/systems/si/derived_units/area_density.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/area_density.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct area_density_synonym{};
 using area_density_t = make_synonym_t<area_density_synonym, decltype(meter<-2> * kilogram<>)>;
 
 inline constexpr area_density_t area_density{};
-using area_density_r = make_refinement_symbol_t<area_density_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/capacitance.hpp b/include/mitama/dimensional/systems/si/derived_units/capacitance.hpp
index 41306ac4..e6265d90 100644
--- a/include/mitama/dimensional/systems/si/derived_units/capacitance.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/capacitance.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct capacitance_synonym{};
 using capacitance_t = make_synonym_t<capacitance_synonym, decltype(kilogram<-1> * meter<-2> * second<4> * ampere<2>)>;
 
 inline constexpr capacitance_t farad{};
-using capacitance_r = make_refinement_symbol_t<capacitance_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/catalytic_activity.hpp b/include/mitama/dimensional/systems/si/derived_units/catalytic_activity.hpp
index cde06b0a..6af97ab6 100644
--- a/include/mitama/dimensional/systems/si/derived_units/catalytic_activity.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/catalytic_activity.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct catalytic_activity_synonym{};
 using catalytic_activity_t = make_synonym_t<catalytic_activity_synonym, decltype(second<-1> * mol<>)>;
 
 inline constexpr catalytic_activity_t katal{};
-using catalytic_activity_r = make_refinement_symbol_t<catalytic_activity_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/catalytic_efficiency.hpp b/include/mitama/dimensional/systems/si/derived_units/catalytic_efficiency.hpp
index f7069b84..48a17aff 100644
--- a/include/mitama/dimensional/systems/si/derived_units/catalytic_efficiency.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/catalytic_efficiency.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct catalytic_efficiency_synonym{};
 using catalytic_efficiency_t = make_synonym_t<catalytic_efficiency_synonym, decltype(meter<3> / (mol<> * second<>))>;
 
 inline constexpr catalytic_efficiency_t catalytic_efficiency{};
-using catalytic_efficiency_r = make_refinement_symbol_t<catalytic_efficiency_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/compressibility.hpp b/include/mitama/dimensional/systems/si/derived_units/compressibility.hpp
index ec09533d..db6013fd 100644
--- a/include/mitama/dimensional/systems/si/derived_units/compressibility.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/compressibility.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct compressibility_synonym{};
 using compressibility_t = make_synonym_t<compressibility_synonym, decltype(meter<> * kilogram<-1> * second<2>)>;
 
 inline constexpr compressibility_t compressibility{};
-using compressibility_r = make_refinement_symbol_t<compressibility_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/conductance.hpp b/include/mitama/dimensional/systems/si/derived_units/conductance.hpp
index b6571b43..26639f68 100644
--- a/include/mitama/dimensional/systems/si/derived_units/conductance.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/conductance.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct conductance_synonym{};
 using conductance_t = make_synonym_t<conductance_synonym, decltype(kilogram<-1> * meter<-2> * second<3> * ampere<2>)>;
 
 inline constexpr conductance_t siemens{};
-using conductance_r = make_refinement_symbol_t<conductance_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/crackle.hpp b/include/mitama/dimensional/systems/si/derived_units/crackle.hpp
index 9e5a4789..8f4ae09f 100644
--- a/include/mitama/dimensional/systems/si/derived_units/crackle.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/crackle.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct crackle_synonym{};
 using crackle_t = make_synonym_t<crackle_synonym, decltype(meters * second<-5>)>;
 
 inline constexpr crackle_t crackle{};
-using crackle_r = make_refinement_symbol_t<crackle_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/curvature.hpp b/include/mitama/dimensional/systems/si/derived_units/curvature.hpp
index ac571947..9d60e7df 100644
--- a/include/mitama/dimensional/systems/si/derived_units/curvature.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/curvature.hpp
@@ -3,14 +3,14 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
 using curvature_t = reciprocal_t<meter_t>;
 
 inline constexpr curvature_t curvature{};
-using curvature_r = make_refinement_symbol_t<curvature_t>;
+
 }
 
 #endif
diff --git a/include/mitama/dimensional/systems/si/derived_units/density.hpp b/include/mitama/dimensional/systems/si/derived_units/density.hpp
index c51d87fe..31fc897e 100644
--- a/include/mitama/dimensional/systems/si/derived_units/density.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/density.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct density_synonym{};
 using density_t = make_synonym_t<density_synonym, decltype(meter<-3> * kilogram<>)>;
 
 inline constexpr density_t density{};
-using density_r = make_refinement_symbol_t<density_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/diffusion_coefficient.hpp b/include/mitama/dimensional/systems/si/derived_units/diffusion_coefficient.hpp
index 11ac7168..7f8377b6 100644
--- a/include/mitama/dimensional/systems/si/derived_units/diffusion_coefficient.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/diffusion_coefficient.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -12,7 +12,7 @@ using diffusion_coefficient_t = make_synonym_t<diffusion_coefficient_synonym, de
 
 #if !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_THERMAL_DIFFUSIVITY_HPP) && !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_KINEMATIC_VISCOSITY_HPP)
 inline constexpr diffusion_coefficient_t diffusion_coefficient{};
-using diffusion_coefficient_r = make_refinement_symbol_t<diffusion_coefficient_t>;
+
 #endif
 }
 
diff --git a/include/mitama/dimensional/systems/si/derived_units/dynamic_viscosity.hpp b/include/mitama/dimensional/systems/si/derived_units/dynamic_viscosity.hpp
index 9e59edd8..c9ee5689 100644
--- a/include/mitama/dimensional/systems/si/derived_units/dynamic_viscosity.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/dynamic_viscosity.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "pressure.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct dynamic_viscosity_synonym{};
 using dynamic_viscosity_t = make_synonym_t<dynamic_viscosity_synonym, decltype(pascal * seconds)>;
 
 inline constexpr dynamic_viscosity_t dynamic_viscosity{};
-using dynamic_viscosity_r = make_refinement_symbol_t<dynamic_viscosity_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/electric_charge.hpp b/include/mitama/dimensional/systems/si/derived_units/electric_charge.hpp
index 4a1b5566..27c62369 100644
--- a/include/mitama/dimensional/systems/si/derived_units/electric_charge.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/electric_charge.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct electric_charge_synonym{};
 using electric_charge_t = make_synonym_t<electric_charge_synonym, decltype(second<> * ampere<>)>;
 
 inline constexpr electric_charge_t coulomb{};
-using electric_charge_r = make_refinement_symbol_t<electric_charge_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/electric_charge_density.hpp b/include/mitama/dimensional/systems/si/derived_units/electric_charge_density.hpp
index bfd5890e..7b6e37ea 100644
--- a/include/mitama/dimensional/systems/si/derived_units/electric_charge_density.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/electric_charge_density.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "electric_charge.hpp"
 
 namespace mitama::systems::si {
@@ -11,9 +11,9 @@ template<class> struct electric_charge_density_synonym{};
 using electric_charge_density_t = make_synonym_t<electric_charge_density_synonym, decltype(coulomb / meter<3>)>;
 
 inline constexpr electric_charge_density_t electric_charge_density{};
-using electric_charge_density_r = make_refinement_symbol_t<electric_charge_density_t>;
+
 inline constexpr electric_charge_density_t charge_density{};
-using electric_charge_density_r = make_refinement_symbol_t<electric_charge_density_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/electric_current_density.hpp b/include/mitama/dimensional/systems/si/derived_units/electric_current_density.hpp
index 9d03c287..8aaffdfb 100644
--- a/include/mitama/dimensional/systems/si/derived_units/electric_current_density.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/electric_current_density.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct electric_current_density_synonym{};
 using electric_current_density_t = make_synonym_t<electric_current_density_synonym, decltype(ampere<> / meter<2>)>;
 
 inline constexpr electric_current_density_t electric_current_density{};
-using electric_current_density_r = make_refinement_symbol_t<electric_current_density_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/electric_displacement_field.hpp b/include/mitama/dimensional/systems/si/derived_units/electric_displacement_field.hpp
index 62108bed..72a7f201 100644
--- a/include/mitama/dimensional/systems/si/derived_units/electric_displacement_field.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/electric_displacement_field.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "electric_charge.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct electric_displacement_field_synonym{};
 using electric_displacement_field_t = make_synonym_t<electric_displacement_field_synonym, decltype(coulomb / meter<2>)>;
 
 inline constexpr electric_displacement_field_t electric_displacement_field{};
-using electric_displacement_field_r = make_refinement_symbol_t<electric_displacement_field_t>;
+
 }
 
 #ifndef MITAMA_DIMENSIONAL_DERIVED_UNITS_POLARIZATION_DENSITY_HPP
diff --git a/include/mitama/dimensional/systems/si/derived_units/electric_field_strength.hpp b/include/mitama/dimensional/systems/si/derived_units/electric_field_strength.hpp
index 4c539ae2..cf11b492 100644
--- a/include/mitama/dimensional/systems/si/derived_units/electric_field_strength.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/electric_field_strength.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "voltage.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct electric_field_strength_synonym{};
 using electric_field_strength_t = make_synonym_t<electric_field_strength_synonym, decltype(volts / meters)>;
 
 inline constexpr electric_field_strength_t electric_field_strength{};
-using electric_field_strength_r = make_refinement_symbol_t<electric_field_strength_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/electric_potential.hpp b/include/mitama/dimensional/systems/si/derived_units/electric_potential.hpp
index 17f5180c..e8739c3e 100644
--- a/include/mitama/dimensional/systems/si/derived_units/electric_potential.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/electric_potential.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -12,7 +12,7 @@ using electric_potential_t = make_synonym_t<electric_potential_synonym, decltype
 
 #ifndef MITAMA_DIMENSIONAL_DERIVED_UNITS_VOLTAGE_HPP
 inline constexpr electric_potential_t volts{};
-using electric_potential_r = make_refinement_symbol_t<electric_potential_t>;
+
 template < std::intmax_t N > 
 inline constexpr powered_t<electric_potential_t, N> volt{}; 
 #endif
diff --git a/include/mitama/dimensional/systems/si/derived_units/electrical_conductivity.hpp b/include/mitama/dimensional/systems/si/derived_units/electrical_conductivity.hpp
index e4b4b939..5703d0df 100644
--- a/include/mitama/dimensional/systems/si/derived_units/electrical_conductivity.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/electrical_conductivity.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "conductance.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct electrical_conductivity_synonym{};
 using electrical_conductivity_t = make_synonym_t<electrical_conductivity_synonym, decltype(siemens / meter<>)>;
 
 inline constexpr electrical_conductivity_t electrical_conductivity{};
-using electrical_conductivity_r = make_refinement_symbol_t<electrical_conductivity_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/electron_mobility.hpp b/include/mitama/dimensional/systems/si/derived_units/electron_mobility.hpp
index 927ab304..4d398deb 100644
--- a/include/mitama/dimensional/systems/si/derived_units/electron_mobility.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/electron_mobility.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "voltage.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct electron_mobility_synonym{};
 using electron_mobility_t = make_synonym_t<electron_mobility_synonym, decltype( meter<2> * volt<-1> * second<-1> )>;
 
 inline constexpr electron_mobility_t electron_mobility{};
-using electron_mobility_r = make_refinement_symbol_t<electron_mobility_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/energy.hpp b/include/mitama/dimensional/systems/si/derived_units/energy.hpp
index 1d521189..8acb1d6e 100644
--- a/include/mitama/dimensional/systems/si/derived_units/energy.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/energy.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -12,7 +12,7 @@ using energy_t = make_synonym_t<energy_synonym, decltype(kilogram<> * meter<2> *
 
 #if !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_HEAT_HPP) && !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_WORK_HPP)
 inline constexpr energy_t joule{};
-using energy_r = make_refinement_symbol_t<energy_t>;
+
 #endif
 }
 
diff --git a/include/mitama/dimensional/systems/si/derived_units/energy_density.hpp b/include/mitama/dimensional/systems/si/derived_units/energy_density.hpp
index ed92a607..53044b4d 100644
--- a/include/mitama/dimensional/systems/si/derived_units/energy_density.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/energy_density.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "energy.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct energy_density_synonym{};
 using energy_density_t = make_synonym_t<energy_density_synonym, decltype(joule / meter<3>)>;
 
 inline constexpr energy_density_t energy_density{};
-using energy_density_r = make_refinement_symbol_t<energy_density_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/energy_flux_density.hpp b/include/mitama/dimensional/systems/si/derived_units/energy_flux_density.hpp
index 1dd5979d..854093ed 100644
--- a/include/mitama/dimensional/systems/si/derived_units/energy_flux_density.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/energy_flux_density.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "energy.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct energy_flux_density_synonym{};
 using energy_flux_density_t = make_synonym_t<energy_flux_density_synonym, decltype( joule * meter<-2> * second<-1> )>;
 
 inline constexpr energy_flux_density_t energy_flux_density{};
-using energy_flux_density_r = make_refinement_symbol_t<energy_flux_density_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/entropy.hpp b/include/mitama/dimensional/systems/si/derived_units/entropy.hpp
index 31bc9a61..f3523c2e 100644
--- a/include/mitama/dimensional/systems/si/derived_units/entropy.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/entropy.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "energy.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct entropy_synonym{};
 using entropy_t = make_synonym_t<entropy_synonym, decltype(joule / kelvins)>;
 
 inline constexpr entropy_t entropy{};
-using entropy_r = make_refinement_symbol_t<entropy_t>;
+
 }
 
 #ifndef MITAMA_DIMENSIONAL_DERIVED_UNITS_HEAT_CAPACITY_HPP
diff --git a/include/mitama/dimensional/systems/si/derived_units/equivalent_dose.hpp b/include/mitama/dimensional/systems/si/derived_units/equivalent_dose.hpp
index 91ffcf46..92691543 100644
--- a/include/mitama/dimensional/systems/si/derived_units/equivalent_dose.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/equivalent_dose.hpp
@@ -3,13 +3,13 @@
 #include <mitama/dimensional/systems/si/base_dimension/equivalent_dose.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 namespace mitama::systems::si {
 using sievert_base_unit = base_units<equivalent_dose, 0>;
 using sievert_t = typename sievert_base_unit::unit_type;
 inline constexpr sievert_t sievert{};
-using equivalent_dose_r = make_refinement_symbol_t<sievert_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/exposure.hpp b/include/mitama/dimensional/systems/si/derived_units/exposure.hpp
index 007c6b6a..253cb951 100644
--- a/include/mitama/dimensional/systems/si/derived_units/exposure.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/exposure.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "electric_charge.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct exposure_synonym{};
 using exposure_t = make_synonym_t<exposure_synonym, decltype(coulomb / kilogram<>)>;
 
 inline constexpr exposure_t exposure{};
-using exposure_r = make_refinement_symbol_t<exposure_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/force.hpp b/include/mitama/dimensional/systems/si/derived_units/force.hpp
index 6b8cc93c..34abb515 100644
--- a/include/mitama/dimensional/systems/si/derived_units/force.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/force.hpp
@@ -3,14 +3,14 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 namespace mitama::systems::si {
 template<class> struct force_synonym{};
 using force_t = make_synonym_t<force_synonym, decltype(kilogram<> * meter<> * second<-2>)>;
 #ifndef MITAMA_DIMENSIONAL_DERIVED_UNITS_WEIGHT_HPP
 inline constexpr force_t newton{};
-using force_r = make_refinement_symbol_t<force_t>;
+
 #endif
 }
 
diff --git a/include/mitama/dimensional/systems/si/derived_units/frequency.hpp b/include/mitama/dimensional/systems/si/derived_units/frequency.hpp
index eb470403..ec871cac 100644
--- a/include/mitama/dimensional/systems/si/derived_units/frequency.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/frequency.hpp
@@ -3,12 +3,12 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 namespace mitama::systems::si {
 using frequency_t = reciprocal_t<second_t>;
 inline constexpr frequency_t hertz{};
-using frequency_r = make_refinement_symbol_t<frequency_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/frequency_drift.hpp b/include/mitama/dimensional/systems/si/derived_units/frequency_drift.hpp
index 7cde1e32..1e23f4d1 100644
--- a/include/mitama/dimensional/systems/si/derived_units/frequency_drift.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/frequency_drift.hpp
@@ -3,14 +3,14 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
 using frequency_drift_t = std::decay_t<decltype(second<-2>)>;
 
 inline constexpr frequency_drift_t frequency_drift{};
-using frequency_drift_r = make_refinement_symbol_t<frequency_drift_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/fuel_efficiency.hpp b/include/mitama/dimensional/systems/si/derived_units/fuel_efficiency.hpp
index a238fabf..133594ea 100644
--- a/include/mitama/dimensional/systems/si/derived_units/fuel_efficiency.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/fuel_efficiency.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct fuel_efficiency_synonym{};
 using fuel_efficiency_t = make_synonym_t<fuel_efficiency_synonym, decltype(meter<-2>)>;
 
 inline constexpr fuel_efficiency_t fuel_efficiency{};
-using fuel_efficiency_r = make_refinement_symbol_t<fuel_efficiency_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/heat.hpp b/include/mitama/dimensional/systems/si/derived_units/heat.hpp
index 7be7872d..18712c56 100644
--- a/include/mitama/dimensional/systems/si/derived_units/heat.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/heat.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -12,7 +12,7 @@ using heat_t = make_synonym_t<heat_synonym, decltype(kilogram<> * meter<2> * sec
 
 #if !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_ENERGY_HPP) && !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_WORK_HPP)
 inline constexpr heat_t joule{};
-using heat_r = make_refinement_symbol_t<heat_t>;
+
 #endif
 }
 
diff --git a/include/mitama/dimensional/systems/si/derived_units/heat_capacity.hpp b/include/mitama/dimensional/systems/si/derived_units/heat_capacity.hpp
index 13fb51f3..19d01fc9 100644
--- a/include/mitama/dimensional/systems/si/derived_units/heat_capacity.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/heat_capacity.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "energy.hpp"
 
 
@@ -12,7 +12,7 @@ template<class> struct heat_capacity_synonym{};
 using heat_capacity_t = make_synonym_t<heat_capacity_synonym, decltype(joule / kelvins)>;
 
 inline constexpr heat_capacity_t heat_capacity{};
-using heat_capacity_r = make_refinement_symbol_t<heat_capacity_t>;
+
 }
 
 #ifndef MITAMA_DIMENSIONAL_DERIVED_UNITS_ENTROPY_HPP
diff --git a/include/mitama/dimensional/systems/si/derived_units/heat_flux.hpp b/include/mitama/dimensional/systems/si/derived_units/heat_flux.hpp
index 9b8c74c3..68ed7b66 100644
--- a/include/mitama/dimensional/systems/si/derived_units/heat_flux.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/heat_flux.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "./power.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct heat_flux_synonym{};
 using heat_flux_t = make_synonym_t<heat_flux_synonym, decltype(watt * meter<-2>)>;
 
 inline constexpr heat_flux_t heat_flux{};
-using heat_flux_r = make_refinement_symbol_t<heat_flux_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/heat_flux_density.hpp b/include/mitama/dimensional/systems/si/derived_units/heat_flux_density.hpp
index 30a37bca..90980874 100644
--- a/include/mitama/dimensional/systems/si/derived_units/heat_flux_density.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/heat_flux_density.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "power.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct heat_flux_density_synonym{};
 using heat_flux_density_t = make_synonym_t<heat_flux_density_synonym, decltype(watt / meter<2>)>;
 
 inline constexpr heat_flux_density_t heat_flux_density{};
-using heat_flux_density_r = make_refinement_symbol_t<heat_flux_density_t>;
+
 }
 
 #ifndef MITAMA_DIMENSIONAL_DERIVED_UNITS_IRRADIANCE_HPP
diff --git a/include/mitama/dimensional/systems/si/derived_units/illuminance.hpp b/include/mitama/dimensional/systems/si/derived_units/illuminance.hpp
index 0edbd21b..0fe36b4a 100644
--- a/include/mitama/dimensional/systems/si/derived_units/illuminance.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/illuminance.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct illuminance_synonym{};
 using illuminance_t = make_synonym_t<illuminance_synonym, decltype(meter<-2> * candela<>)>;
 
 inline constexpr illuminance_t lux{};
-using illuminance_r = make_refinement_symbol_t<illuminance_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/impedance.hpp b/include/mitama/dimensional/systems/si/derived_units/impedance.hpp
index 89f2fd75..6f7d0686 100644
--- a/include/mitama/dimensional/systems/si/derived_units/impedance.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/impedance.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -12,7 +12,7 @@ using impedance_t = make_synonym_t<impedance_synonym, decltype(kilogram<> * mete
 
 #if !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_RESISTANCE_HPP) && !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_REACTANCE_HPP)
 inline constexpr impedance_t ohm{};
-using impedance_r = make_refinement_symbol_t<impedance_t>;
+
 #endif
 }
 
diff --git a/include/mitama/dimensional/systems/si/derived_units/impulse.hpp b/include/mitama/dimensional/systems/si/derived_units/impulse.hpp
index ac3efa4d..6be562cf 100644
--- a/include/mitama/dimensional/systems/si/derived_units/impulse.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/impulse.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct impulse_synonym{};
 using impulse_t = make_synonym_t<impulse_synonym, decltype(meter<> * kilogram<> * second<-1>)>;
 
 inline constexpr impulse_t impulse{};
-using impulse_r = make_refinement_symbol_t<impulse_t>;
+
 }
 
 #ifndef MITAMA_DIMENSIONAL_DERIVED_UNITS_MOMENTUM_HPP
diff --git a/include/mitama/dimensional/systems/si/derived_units/inductance.hpp b/include/mitama/dimensional/systems/si/derived_units/inductance.hpp
index b706bcee..540a05d4 100644
--- a/include/mitama/dimensional/systems/si/derived_units/inductance.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/inductance.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct inductance_synonym{};
 using inductance_t = make_synonym_t<inductance_synonym, decltype(kilogram<> * meter<2> * second<-2> * ampere<-2>)>;
 
 inline constexpr inductance_t henry{};
-using inductance_r = make_refinement_symbol_t<inductance_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/irradiance.hpp b/include/mitama/dimensional/systems/si/derived_units/irradiance.hpp
index f6d59894..f405afe0 100644
--- a/include/mitama/dimensional/systems/si/derived_units/irradiance.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/irradiance.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "power.hpp"
 
 namespace mitama::systems::si {
@@ -12,7 +12,7 @@ using irradiance_t = make_synonym_t<irradiance_synonym, decltype(watt * meter<-2
 
 #ifndef MITAMA_DIMENSIONAL_DERIVED_UNITS_HEAT_FLUX_DENSITY_HPP
 inline constexpr irradiance_t irradiance{};
-using irradiance_r = make_refinement_symbol_t<irradiance_t>;
+
 #endif
 }
 
diff --git a/include/mitama/dimensional/systems/si/derived_units/jerk.hpp b/include/mitama/dimensional/systems/si/derived_units/jerk.hpp
index 24ac6b1d..b12da70b 100644
--- a/include/mitama/dimensional/systems/si/derived_units/jerk.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/jerk.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct jerk_synonym{};
 using jerk_t = make_synonym_t<jerk_synonym, decltype(meters * second<-3>)>;
 
 inline constexpr jerk_t jerk{};
-using jerk_r = make_refinement_symbol_t<jerk_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/kinematic_viscosity.hpp b/include/mitama/dimensional/systems/si/derived_units/kinematic_viscosity.hpp
index 132284e6..6edefb0d 100644
--- a/include/mitama/dimensional/systems/si/derived_units/kinematic_viscosity.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/kinematic_viscosity.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -12,7 +12,7 @@ using kinematic_viscosity_t = make_synonym_t<kinematic_viscosity_synonym, declty
 
 #if !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_THERMAL_DIFFUSIVITY_HPP) && !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_DIFFUSION_COEFFICIENT_HPP)
 inline constexpr kinematic_viscosity_t kinematic_viscosity{};
-using kinematic_viscosity_r = make_refinement_symbol_t<kinematic_viscosity_t>;
+
 #endif
 }
 
diff --git a/include/mitama/dimensional/systems/si/derived_units/linear_charge_density.hpp b/include/mitama/dimensional/systems/si/derived_units/linear_charge_density.hpp
index 604d937e..f0fa1dc2 100644
--- a/include/mitama/dimensional/systems/si/derived_units/linear_charge_density.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/linear_charge_density.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "electric_charge.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct linear_charge_density_synonym{};
 using linear_charge_density_t = make_synonym_t<linear_charge_density_synonym, decltype(coulomb / meter<>)>;
 
 inline constexpr linear_charge_density_t linear_charge_density{};
-using linear_charge_density_r = make_refinement_symbol_t<linear_charge_density_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/linear_mass_density.hpp b/include/mitama/dimensional/systems/si/derived_units/linear_mass_density.hpp
index 60b78326..9357d1ce 100644
--- a/include/mitama/dimensional/systems/si/derived_units/linear_mass_density.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/linear_mass_density.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct linear_mass_density_synonym{};
 using linear_mass_density_t = make_synonym_t<linear_mass_density_synonym, decltype(meter<-1> * kilogram<>)>;
 
 inline constexpr linear_mass_density_t linear_mass_density{};
-using linear_mass_density_r = make_refinement_symbol_t<linear_mass_density_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/luminance.hpp b/include/mitama/dimensional/systems/si/derived_units/luminance.hpp
index da896e59..5c0f28c5 100644
--- a/include/mitama/dimensional/systems/si/derived_units/luminance.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/luminance.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct luminance_synonym{};
 using luminance_t = make_synonym_t<luminance_synonym, decltype(candela<> * meter<-2>)>;
 
 inline constexpr luminance_t luminance{};
-using luminance_r = make_refinement_symbol_t<luminance_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/luminous_efficacy.hpp b/include/mitama/dimensional/systems/si/derived_units/luminous_efficacy.hpp
index 3c115625..609a8d66 100644
--- a/include/mitama/dimensional/systems/si/derived_units/luminous_efficacy.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/luminous_efficacy.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "power.hpp"
 #include "luminous_flux.hpp"
 
@@ -12,7 +12,7 @@ template<class> struct luminous_efficacy_synonym{};
 using luminous_efficacy_t = make_synonym_t<luminous_efficacy_synonym, decltype(lumen / watt)>;
 
 inline constexpr luminous_efficacy_t luminous_efficacy{};
-using luminous_efficacy_r = make_refinement_symbol_t<luminous_efficacy_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/luminous_energy.hpp b/include/mitama/dimensional/systems/si/derived_units/luminous_energy.hpp
index 97834ba0..3940dfe1 100644
--- a/include/mitama/dimensional/systems/si/derived_units/luminous_energy.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/luminous_energy.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "luminous_flux.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct luminous_energy_synonym{};
 using luminous_energy_t = make_synonym_t<luminous_energy_synonym, decltype(lumen * second<>)>;
 
 inline constexpr luminous_energy_t luminous_energy{};
-using luminous_energy_r = make_refinement_symbol_t<luminous_energy_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/luminous_exposure.hpp b/include/mitama/dimensional/systems/si/derived_units/luminous_exposure.hpp
index 6db6bae0..05bb1ce3 100644
--- a/include/mitama/dimensional/systems/si/derived_units/luminous_exposure.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/luminous_exposure.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "solid_angle.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct luminous_exposure_synonym{};
 using luminous_exposure_t = make_synonym_t<luminous_exposure_synonym, decltype(meter<-2>*seconds*candela<>*steradian)>;
 
 inline constexpr luminous_exposure_t luminous_exposure{};
-using luminous_exposure_r = make_refinement_symbol_t<luminous_exposure_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/luminous_flux.hpp b/include/mitama/dimensional/systems/si/derived_units/luminous_flux.hpp
index 011f5702..8e60ddb5 100644
--- a/include/mitama/dimensional/systems/si/derived_units/luminous_flux.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/luminous_flux.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "solid_angle.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct luminous_flux_synonym{};
 using luminous_flux_t = make_synonym_t<luminous_flux_synonym, decltype(candela<> * steradian)>;
 
 inline constexpr luminous_flux_t lumen{};
-using luminous_flux_r = make_refinement_symbol_t<luminous_flux_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/magnetic_dipole_moment.hpp b/include/mitama/dimensional/systems/si/derived_units/magnetic_dipole_moment.hpp
index 6b2b15d8..e61f5361 100644
--- a/include/mitama/dimensional/systems/si/derived_units/magnetic_dipole_moment.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/magnetic_dipole_moment.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "energy.hpp"
 #include "magnetic_flux_density.hpp"
 
@@ -12,7 +12,7 @@ template<class> struct magnetic_dipole_moment_synonym{};
 using magnetic_dipole_moment_t = make_synonym_t<magnetic_dipole_moment_synonym, decltype(joule / tesla)>;
 
 inline constexpr magnetic_dipole_moment_t magnetic_dipole_moment{};
-using magnetic_dipole_moment_r = make_refinement_symbol_t<magnetic_dipole_moment_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/magnetic_field_strength.hpp b/include/mitama/dimensional/systems/si/derived_units/magnetic_field_strength.hpp
index 9e091ac9..2b1c7fa3 100644
--- a/include/mitama/dimensional/systems/si/derived_units/magnetic_field_strength.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/magnetic_field_strength.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct magnetic_field_strength_synonym{};
 using magnetic_field_strength_t = make_synonym_t<magnetic_field_strength_synonym, decltype(ampere<> / meter<>)>;
 
 inline constexpr magnetic_field_strength_t magnetic_field_strength{};
-using magnetic_field_strength_r = make_refinement_symbol_t<magnetic_field_strength_t>;
+
 }
 
 #ifndef MITAMA_DIMENSIONAL_DERIVED_UNITS_MAGNETIZATION_HPP
diff --git a/include/mitama/dimensional/systems/si/derived_units/magnetic_flux.hpp b/include/mitama/dimensional/systems/si/derived_units/magnetic_flux.hpp
index cf7f3e6f..a567d8d9 100644
--- a/include/mitama/dimensional/systems/si/derived_units/magnetic_flux.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/magnetic_flux.hpp
@@ -3,14 +3,14 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 namespace mitama::systems::si {
 template<class> struct magnetic_flux_synonym{};
 using magnetic_flux_t = make_synonym_t<magnetic_flux_synonym, decltype(kilogram<> * meter<2> * second<-2> * ampere<-1>)>;
 
 inline constexpr magnetic_flux_t weber{};
-using magnetic_flux_r = make_refinement_symbol_t<magnetic_flux_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/magnetic_flux_density.hpp b/include/mitama/dimensional/systems/si/derived_units/magnetic_flux_density.hpp
index 08faee90..23a622da 100644
--- a/include/mitama/dimensional/systems/si/derived_units/magnetic_flux_density.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/magnetic_flux_density.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct magnetic_flux_density_synonym{};
 using magnetic_flux_density_t = make_synonym_t<magnetic_flux_density_synonym, decltype(kilogram<> * second<-2> * ampere<-1>)>;
 
 inline constexpr magnetic_flux_density_t tesla{};
-using magnetic_flux_density_r = make_refinement_symbol_t<magnetic_flux_density_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/magnetic_moment.hpp b/include/mitama/dimensional/systems/si/derived_units/magnetic_moment.hpp
index 26ef8eef..12cc0e1c 100644
--- a/include/mitama/dimensional/systems/si/derived_units/magnetic_moment.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/magnetic_moment.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "magnetic_flux.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct magnetic_moment_synonym{};
 using magnetic_moment_t = make_synonym_t<magnetic_moment_synonym, decltype(weber * meter<>)>;
 
 inline constexpr magnetic_moment_t magnetic_moment{};
-using magnetic_moment_r = make_refinement_symbol_t<magnetic_moment_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/magnetic_reluctance.hpp b/include/mitama/dimensional/systems/si/derived_units/magnetic_reluctance.hpp
index b04e4043..c75b7542 100644
--- a/include/mitama/dimensional/systems/si/derived_units/magnetic_reluctance.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/magnetic_reluctance.hpp
@@ -3,14 +3,14 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
 using magnetic_reluctance_t = reciprocal_t<decltype(kilogram<> * meter<2> * second<-2> * ampere<-2>)>;
 
 inline constexpr magnetic_reluctance_t magnetic_reluctance{};
-using magnetic_reluctance_r = make_refinement_symbol_t<magnetic_reluctance_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/magnetic_rigidity.hpp b/include/mitama/dimensional/systems/si/derived_units/magnetic_rigidity.hpp
index a073ca92..9de2f761 100644
--- a/include/mitama/dimensional/systems/si/derived_units/magnetic_rigidity.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/magnetic_rigidity.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "magnetic_flux_density.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct magnetic_rigidity_synonym{};
 using magnetic_rigidity_t = make_synonym_t<magnetic_rigidity_synonym, decltype(tesla * meter<>)>;
 
 inline constexpr magnetic_rigidity_t magnetic_rigidity{};
-using magnetic_rigidity_r = make_refinement_symbol_t<magnetic_rigidity_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/magnetic_susceptibility.hpp b/include/mitama/dimensional/systems/si/derived_units/magnetic_susceptibility.hpp
index 1abc049b..3a0df71d 100644
--- a/include/mitama/dimensional/systems/si/derived_units/magnetic_susceptibility.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/magnetic_susceptibility.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "inductance.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct magnetic_susceptibility_synonym{};
 using magnetic_susceptibility_t = make_synonym_t<magnetic_susceptibility_synonym, decltype(meter<> / henry)>;
 
 inline constexpr magnetic_susceptibility_t magnetic_susceptibility{};
-using magnetic_susceptibility_r = make_refinement_symbol_t<magnetic_susceptibility_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/magnetic_vector_potential.hpp b/include/mitama/dimensional/systems/si/derived_units/magnetic_vector_potential.hpp
index 0840bc96..78a60323 100644
--- a/include/mitama/dimensional/systems/si/derived_units/magnetic_vector_potential.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/magnetic_vector_potential.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "magnetic_flux.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct magnetic_vector_potential_synonym{};
 using magnetic_vector_potential_t = make_synonym_t<magnetic_vector_potential_synonym, decltype(weber / meter<>)>;
 
 inline constexpr magnetic_vector_potential_t magnetic_vector_potential{};
-using magnetic_vector_potential_r = make_refinement_symbol_t<magnetic_vector_potential_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/magnetization.hpp b/include/mitama/dimensional/systems/si/derived_units/magnetization.hpp
index 7c0055e6..b77113d6 100644
--- a/include/mitama/dimensional/systems/si/derived_units/magnetization.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/magnetization.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct magnetization_synonym{};
 using magnetization_t = make_synonym_t<magnetization_synonym, decltype(ampere<> / meter<>)>;
 
 inline constexpr magnetization_t magnetization{};
-using magnetization_r = make_refinement_symbol_t<magnetization_t>;
+
 }
 
 #ifndef MITAMA_DIMENSIONAL_DERIVED_UNITS_MAGNETIC_FIELD_STRENGTH_HPP
diff --git a/include/mitama/dimensional/systems/si/derived_units/magnetomotive_force.hpp b/include/mitama/dimensional/systems/si/derived_units/magnetomotive_force.hpp
index d934663f..22a69fcc 100644
--- a/include/mitama/dimensional/systems/si/derived_units/magnetomotive_force.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/magnetomotive_force.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "angle.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct magnetomotive_force_synonym{};
 using magnetomotive_force_t = make_synonym_t<magnetomotive_force_synonym, decltype(ampere<> * radian)>;
 
 inline constexpr magnetomotive_force_t magnetomotive_force{};
-using magnetomotive_force_r = make_refinement_symbol_t<magnetomotive_force_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/mass_flow_rate.hpp b/include/mitama/dimensional/systems/si/derived_units/mass_flow_rate.hpp
index 1817b95a..c98c6a36 100644
--- a/include/mitama/dimensional/systems/si/derived_units/mass_flow_rate.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/mass_flow_rate.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct mass_flow_rate_synonym{};
 using mass_flow_rate_t = make_synonym_t<mass_flow_rate_synonym, decltype(kilogram<> / second<>)>;
 
 inline constexpr mass_flow_rate_t mass_flow_rate{};
-using mass_flow_rate_r = make_refinement_symbol_t<mass_flow_rate_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/molality.hpp b/include/mitama/dimensional/systems/si/derived_units/molality.hpp
index c9e17b9e..7c79fd1f 100644
--- a/include/mitama/dimensional/systems/si/derived_units/molality.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/molality.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct molality_synonym{};
 using molality_t = make_synonym_t<molality_synonym, decltype(mol<> / kilogram<>)>;
 
 inline constexpr molality_t molality{};
-using molality_r = make_refinement_symbol_t<molality_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/molar_conductivity.hpp b/include/mitama/dimensional/systems/si/derived_units/molar_conductivity.hpp
index 191506b0..99ba3a49 100644
--- a/include/mitama/dimensional/systems/si/derived_units/molar_conductivity.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/molar_conductivity.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "conductance.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct molar_conductivity_synonym{};
 using molar_conductivity_t = make_synonym_t<molar_conductivity_synonym, decltype(siemens * meter<2> / mol<>)>;
 
 inline constexpr molar_conductivity_t molar_conductivity{};
-using molar_conductivity_r = make_refinement_symbol_t<molar_conductivity_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/molar_energy.hpp b/include/mitama/dimensional/systems/si/derived_units/molar_energy.hpp
index 500f58ea..6547d6e8 100644
--- a/include/mitama/dimensional/systems/si/derived_units/molar_energy.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/molar_energy.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "energy.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct molar_energy_synonym{};
 using molar_energy_t = make_synonym_t<molar_energy_synonym, decltype(joule / mol<>)>;
 
 inline constexpr molar_energy_t molar_energy{};
-using molar_energy_r = make_refinement_symbol_t<molar_energy_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/molar_entropy.hpp b/include/mitama/dimensional/systems/si/derived_units/molar_entropy.hpp
index 5138eec1..ec77fda0 100644
--- a/include/mitama/dimensional/systems/si/derived_units/molar_entropy.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/molar_entropy.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "energy.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct molar_entropy_synonym{};
 using molar_entropy_t = make_synonym_t<molar_entropy_synonym, decltype( joule / (kelvin<> * mol<>) )>;
 
 inline constexpr molar_entropy_t molar_entropy{};
-using molar_entropy_r = make_refinement_symbol_t<molar_entropy_t>;
+
 }
 
 #ifndef MITAMA_DIMENSIONAL_DERIVED_UNITS_MOLAR_HEAT_CAPACITY_HPP
diff --git a/include/mitama/dimensional/systems/si/derived_units/molar_heat_capacity.hpp b/include/mitama/dimensional/systems/si/derived_units/molar_heat_capacity.hpp
index d500ce8b..5f451eef 100644
--- a/include/mitama/dimensional/systems/si/derived_units/molar_heat_capacity.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/molar_heat_capacity.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "energy.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct molar_heat_capacity_synonym{};
 using molar_heat_capacity_t = make_synonym_t<molar_heat_capacity_synonym, decltype( joule / (kelvin<> * mol<>) )>;
 
 inline constexpr molar_heat_capacity_t molar_heat_capacity{};
-using molar_heat_capacity_r = make_refinement_symbol_t<molar_heat_capacity_t>;
+
 }
 
 #ifndef MITAMA_DIMENSIONAL_DERIVED_UNITS_MOLAR_ENTROPY_HPP
diff --git a/include/mitama/dimensional/systems/si/derived_units/molar_mass.hpp b/include/mitama/dimensional/systems/si/derived_units/molar_mass.hpp
index d4fa4b4e..73dc6a4e 100644
--- a/include/mitama/dimensional/systems/si/derived_units/molar_mass.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/molar_mass.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct molar_mass_synonym{};
 using molar_mass_t = make_synonym_t<molar_mass_synonym, decltype(kilogram<> / mol<>)>;
 
 inline constexpr molar_mass_t molar_mass{};
-using molar_mass_r = make_refinement_symbol_t<molar_mass_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/molar_volume.hpp b/include/mitama/dimensional/systems/si/derived_units/molar_volume.hpp
index c2327f32..3eaeca14 100644
--- a/include/mitama/dimensional/systems/si/derived_units/molar_volume.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/molar_volume.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct molar_volume_synonym{};
 using molar_volume_t = make_synonym_t<molar_volume_synonym, decltype(meter<3> / mol<>)>;
 
 inline constexpr molar_volume_t molar_volume{};
-using molar_volume_r = make_refinement_symbol_t<molar_volume_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/molarity.hpp b/include/mitama/dimensional/systems/si/derived_units/molarity.hpp
index 8ebcc683..d1c71402 100644
--- a/include/mitama/dimensional/systems/si/derived_units/molarity.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/molarity.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct molarity_synonym{};
 using molarity_t = make_synonym_t<molarity_synonym, decltype(mol<> / meter<3>)>;
 
 inline constexpr molarity_t molarity{};
-using molarity_r = make_refinement_symbol_t<molarity_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/moment_of_inertia.hpp b/include/mitama/dimensional/systems/si/derived_units/moment_of_inertia.hpp
index 9c747f7f..f2ddfe88 100644
--- a/include/mitama/dimensional/systems/si/derived_units/moment_of_inertia.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/moment_of_inertia.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct moment_of_inertia_synonym{};
 using moment_of_inertia_t = make_synonym_t<moment_of_inertia_synonym, decltype(kilogram<> * meter<2>)>;
 
 inline constexpr moment_of_inertia_t moment_of_inertia{};
-using moment_of_inertia_r = make_refinement_symbol_t<moment_of_inertia_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/momentum.hpp b/include/mitama/dimensional/systems/si/derived_units/momentum.hpp
index 17a49c4e..739a69c1 100644
--- a/include/mitama/dimensional/systems/si/derived_units/momentum.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/momentum.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct momentum_synonym{};
 using momentum_t = make_synonym_t<momentum_synonym, decltype(meter<> * kilogram<> * second<-1>)>;
 
 inline constexpr momentum_t momentum{};
-using momentum_r = make_refinement_symbol_t<momentum_t>;
+
 }
 
 #ifndef MITAMA_DIMENSIONAL_DERIVED_UNITS_IMPULSE_HPP
diff --git a/include/mitama/dimensional/systems/si/derived_units/optical_power.hpp b/include/mitama/dimensional/systems/si/derived_units/optical_power.hpp
index 7910ff90..2e635432 100644
--- a/include/mitama/dimensional/systems/si/derived_units/optical_power.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/optical_power.hpp
@@ -3,14 +3,14 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
 using optical_power_t = reciprocal_t<meter_t>;
 
 inline constexpr optical_power_t optical_power{};
-using optical_power_r = make_refinement_symbol_t<optical_power_t>;
+
 }
 
 #endif
diff --git a/include/mitama/dimensional/systems/si/derived_units/permeability.hpp b/include/mitama/dimensional/systems/si/derived_units/permeability.hpp
index e8750db7..2c70223e 100644
--- a/include/mitama/dimensional/systems/si/derived_units/permeability.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/permeability.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "inductance.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct permeability_synonym{};
 using permeability_t = make_synonym_t<permeability_synonym, decltype(henry / meter<>)>;
 
 inline constexpr permeability_t permeability{};
-using permeability_r = make_refinement_symbol_t<permeability_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/permittivity.hpp b/include/mitama/dimensional/systems/si/derived_units/permittivity.hpp
index ab89c699..f5faa7fa 100644
--- a/include/mitama/dimensional/systems/si/derived_units/permittivity.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/permittivity.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "capacitance.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct permittivity_synonym{};
 using permittivity_t = make_synonym_t<permittivity_synonym, decltype(farad / meter<>)>;
 
 inline constexpr permittivity_t permittivity{};
-using permittivity_r = make_refinement_symbol_t<permittivity_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/polarization_density.hpp b/include/mitama/dimensional/systems/si/derived_units/polarization_density.hpp
index e621bba1..88f8c395 100644
--- a/include/mitama/dimensional/systems/si/derived_units/polarization_density.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/polarization_density.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "electric_charge.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct polarization_density_synonym{};
 using polarization_density_t = make_synonym_t<polarization_density_synonym, decltype(coulomb / meter<2>)>;
 
 inline constexpr polarization_density_t polarization_density{};
-using polarization_density_r = make_refinement_symbol_t<polarization_density_t>;
+
 }
 
 #ifndef MITAMA_DIMENSIONAL_DERIVED_UNITS_ELECTRIC_DISPLACEMENT_FIELD_HPP
diff --git a/include/mitama/dimensional/systems/si/derived_units/pop.hpp b/include/mitama/dimensional/systems/si/derived_units/pop.hpp
index 094d463e..59dc9958 100644
--- a/include/mitama/dimensional/systems/si/derived_units/pop.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/pop.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct pop_synonym{};
 using pop_t = make_synonym_t<pop_synonym, decltype(meters * second<-6>)>;
 
 inline constexpr pop_t pop{};
-using pop_r = make_refinement_symbol_t<pop_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/power.hpp b/include/mitama/dimensional/systems/si/derived_units/power.hpp
index 92d5c85c..0b6d1252 100644
--- a/include/mitama/dimensional/systems/si/derived_units/power.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/power.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct power_synonym{};
 using power_t = make_synonym_t<power_synonym, decltype(kilogram<> * meter<2> * second<-3>)>;
 
 inline constexpr power_t watt{};
-using power_r = make_refinement_symbol_t<power_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/power_density.hpp b/include/mitama/dimensional/systems/si/derived_units/power_density.hpp
index fa2ab8e8..fb0ab8f6 100644
--- a/include/mitama/dimensional/systems/si/derived_units/power_density.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/power_density.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "power.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct power_density_synonym{};
 using power_density_t = make_synonym_t<power_density_synonym, decltype(watt / meter<3>)>;
 
 inline constexpr power_density_t power_density{};
-using power_density_r = make_refinement_symbol_t<power_density_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/pressure.hpp b/include/mitama/dimensional/systems/si/derived_units/pressure.hpp
index f70c09e4..24f4c6ab 100644
--- a/include/mitama/dimensional/systems/si/derived_units/pressure.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/pressure.hpp
@@ -6,13 +6,13 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 namespace mitama::systems::si {
 template<class> struct pressure_synonym{};
 using pressure_t = make_synonym_t<pressure_synonym, decltype(kilogram<> * meter<-1> * second<-2>)>;
 inline constexpr pressure_t pascal{};
-using pressure_r = make_refinement_symbol_t<pressure_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/radiance.hpp b/include/mitama/dimensional/systems/si/derived_units/radiance.hpp
index 7b84a987..7221715c 100644
--- a/include/mitama/dimensional/systems/si/derived_units/radiance.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/radiance.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "power.hpp"
 #include "solid_angle.hpp"
 
@@ -12,7 +12,7 @@ template<class> struct radiance_synonym{};
 using radiance_t = make_synonym_t<radiance_synonym, decltype( watt / steradian * meter<-2> )>;
 
 inline constexpr radiance_t radiance{};
-using radiance_r = make_refinement_symbol_t<radiance_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/radiant_exposure.hpp b/include/mitama/dimensional/systems/si/derived_units/radiant_exposure.hpp
index 3e433555..e9df23da 100644
--- a/include/mitama/dimensional/systems/si/derived_units/radiant_exposure.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/radiant_exposure.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "energy.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct radiant_exposure_synonym{};
 using radiant_exposure_t = make_synonym_t<radiant_exposure_synonym, decltype(joule / meter<2>)>;
 
 inline constexpr radiant_exposure_t radiant_exposure{};
-using radiant_exposure_r = make_refinement_symbol_t<radiant_exposure_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/radiant_flux.hpp b/include/mitama/dimensional/systems/si/derived_units/radiant_flux.hpp
index f4ef49e2..d06bfeb1 100644
--- a/include/mitama/dimensional/systems/si/derived_units/radiant_flux.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/radiant_flux.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -12,7 +12,7 @@ using radiant_flux_t = make_synonym_t<radiant_flux_synonym, decltype(kilogram<>
 
 #ifndef MITAMA_DIMENSIONAL_DERIVED_UNITS_POWER_HPP
 inline constexpr radiant_flux_t watt{};
-using radiant_flux_r = make_refinement_symbol_t<radiant_flux_t>;
+
 #endif
 }
 
diff --git a/include/mitama/dimensional/systems/si/derived_units/radiant_intensity.hpp b/include/mitama/dimensional/systems/si/derived_units/radiant_intensity.hpp
index a74093db..0e1cfc70 100644
--- a/include/mitama/dimensional/systems/si/derived_units/radiant_intensity.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/radiant_intensity.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "power.hpp"
 #include "solid_angle.hpp"
 
@@ -12,7 +12,7 @@ template<class> struct radiant_intensity_synonym{};
 using radiant_intensity_t = make_synonym_t<radiant_intensity_synonym, decltype(watt / steradian)>;
 
 inline constexpr radiant_intensity_t radiant_intensity{};
-using radiant_intensity_r = make_refinement_symbol_t<radiant_intensity_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/radioactivity.hpp b/include/mitama/dimensional/systems/si/derived_units/radioactivity.hpp
index 58e3e917..9ea93af1 100644
--- a/include/mitama/dimensional/systems/si/derived_units/radioactivity.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/radioactivity.hpp
@@ -3,13 +3,13 @@
 #include <mitama/dimensional/systems/si/base_dimension/radio_activity.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 namespace mitama::systems::si {
 using radio_activity_base_unit = base_units<radio_activity, 0>;
 using radioactivity_t = typename radio_activity_base_unit::unit_type;
 inline constexpr radioactivity_t becquerel{};
-using radioactivity_r = make_refinement_symbol_t<radioactivity_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/reactance.hpp b/include/mitama/dimensional/systems/si/derived_units/reactance.hpp
index bc58fd94..e949eb91 100644
--- a/include/mitama/dimensional/systems/si/derived_units/reactance.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/reactance.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -12,7 +12,7 @@ using reactance_t = make_synonym_t<reactance_synonym, decltype(kilogram<> * mete
 
 #if !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_RESISTANCE_HPP) && !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_IMPEDANCE_HPP)
 inline constexpr reactance_t ohm{};
-using reactance_r = make_refinement_symbol_t<reactance_t>;
+
 #endif
 }
 
diff --git a/include/mitama/dimensional/systems/si/derived_units/resistance.hpp b/include/mitama/dimensional/systems/si/derived_units/resistance.hpp
index f1812b4d..a4204e14 100644
--- a/include/mitama/dimensional/systems/si/derived_units/resistance.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/resistance.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -12,7 +12,7 @@ using resistance_t = make_synonym_t<resistance_synonym, decltype(kilogram<> * me
 
 #if !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_REACTANCE_HPP) && !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_REACTANCE_HPP)
 inline constexpr resistance_t ohm{};
-using resistance_r = make_refinement_symbol_t<resistance_t>;
+
 #endif
 }
 
diff --git a/include/mitama/dimensional/systems/si/derived_units/resistivity.hpp b/include/mitama/dimensional/systems/si/derived_units/resistivity.hpp
index 330cfe7d..5a0de350 100644
--- a/include/mitama/dimensional/systems/si/derived_units/resistivity.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/resistivity.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "resistance.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct resistivity_synonym{};
 using resistivity_t = make_synonym_t<resistivity_synonym, decltype(ohm * meter<>)>;
 
 inline constexpr resistivity_t resistivity{};
-using resistivity_r = make_refinement_symbol_t<resistivity_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/snap.hpp b/include/mitama/dimensional/systems/si/derived_units/snap.hpp
index f2514774..2210e70d 100644
--- a/include/mitama/dimensional/systems/si/derived_units/snap.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/snap.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct snap_synonym{};
 using snap_t = make_synonym_t<snap_synonym, decltype(meters * second<-4>)>;
 
 inline constexpr snap_t snap{};
-using snap_r = make_refinement_symbol_t<snap_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/solid_angle.hpp b/include/mitama/dimensional/systems/si/derived_units/solid_angle.hpp
index d86b0b0d..4a26a383 100644
--- a/include/mitama/dimensional/systems/si/derived_units/solid_angle.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/solid_angle.hpp
@@ -3,13 +3,13 @@
 #include <mitama/dimensional/systems/si/base_dimension/solid_angle.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 namespace mitama::systems::si {
 using steradian_base_unit = base_units<solid_angle, 0>;
 using steradian_t = typename steradian_base_unit::unit_type;
 inline constexpr steradian_t steradian{};
-using steradian_r = make_refinement_symbol_t<steradian_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/spatial_frequency.hpp b/include/mitama/dimensional/systems/si/derived_units/spatial_frequency.hpp
index ab2fee74..444d4e73 100644
--- a/include/mitama/dimensional/systems/si/derived_units/spatial_frequency.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/spatial_frequency.hpp
@@ -3,14 +3,14 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
 using spatial_frequency_t = reciprocal_t<meter_t>;
 
 inline constexpr spatial_frequency_t spatial_frequency{};
-using spatial_frequency_r = make_refinement_symbol_t<spatial_frequency_t>;
+
 }
 
 #endif
diff --git a/include/mitama/dimensional/systems/si/derived_units/specific_angular_momentum.hpp b/include/mitama/dimensional/systems/si/derived_units/specific_angular_momentum.hpp
index 6a8b153e..98d9de68 100644
--- a/include/mitama/dimensional/systems/si/derived_units/specific_angular_momentum.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/specific_angular_momentum.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct specific_angular_momentum_synonym{};
 using specific_angular_momentum_t = make_synonym_t<specific_angular_momentum_synonym, decltype(meter<2> * second<-1>)>;
 
 inline constexpr specific_angular_momentum_t specific_angular_momentum{};
-using specific_angular_momentum_r = make_refinement_symbol_t<specific_angular_momentum_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/specific_energy.hpp b/include/mitama/dimensional/systems/si/derived_units/specific_energy.hpp
index adda3310..adf0376f 100644
--- a/include/mitama/dimensional/systems/si/derived_units/specific_energy.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/specific_energy.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "energy.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct specific_energy_synonym{};
 using specific_energy_t = make_synonym_t<specific_energy_synonym, decltype(joule / kilogram<>)>;
 
 inline constexpr specific_energy_t specific_energy{};
-using specific_energy_r = make_refinement_symbol_t<specific_energy_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/specific_entropy.hpp b/include/mitama/dimensional/systems/si/derived_units/specific_entropy.hpp
index 02d74ef3..2ebf3ca1 100644
--- a/include/mitama/dimensional/systems/si/derived_units/specific_entropy.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/specific_entropy.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "energy.hpp"
 
 
@@ -12,7 +12,7 @@ template<class> struct specific_entropy_synonym{};
 using specific_entropy_t = make_synonym_t<specific_entropy_synonym, decltype( joule / (kilograms * kelvins) )>;
 
 inline constexpr specific_entropy_t specific_entropy{};
-using specific_entropy_r = make_refinement_symbol_t<specific_entropy_t>;
+
 }
 
 #ifndef MITAMA_DIMENSIONAL_DERIVED_UNITS_SPECIFIC_HEAT_CAPACITY_HPP
diff --git a/include/mitama/dimensional/systems/si/derived_units/specific_heat_capacity.hpp b/include/mitama/dimensional/systems/si/derived_units/specific_heat_capacity.hpp
index b7ae350a..b18ee966 100644
--- a/include/mitama/dimensional/systems/si/derived_units/specific_heat_capacity.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/specific_heat_capacity.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "energy.hpp"
 
 
@@ -12,7 +12,7 @@ template<class> struct specific_heat_capacity_synonym{};
 using specific_heat_capacity_t = make_synonym_t<specific_heat_capacity_synonym, decltype( joule * kilogram<-1> * kelvin<-1> )>;
 
 inline constexpr specific_heat_capacity_t specific_heat_capacity{};
-using specific_heat_capacity_r = make_refinement_symbol_t<specific_heat_capacity_t>;
+
 }
 
 #ifndef MITAMA_DIMENSIONAL_DERIVED_UNITS_SPECIFIC_ENTROPY_HPP
diff --git a/include/mitama/dimensional/systems/si/derived_units/specific_volume.hpp b/include/mitama/dimensional/systems/si/derived_units/specific_volume.hpp
index 9b06c125..feb39ca3 100644
--- a/include/mitama/dimensional/systems/si/derived_units/specific_volume.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/specific_volume.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct specific_volume_synonym{};
 using specific_volume_t = make_synonym_t<specific_volume_synonym, decltype(meter<3> / kilogram<>)>;
 
 inline constexpr specific_volume_t specific_volume{};
-using specific_volume_r = make_refinement_symbol_t<specific_volume_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/spectral_intensity.hpp b/include/mitama/dimensional/systems/si/derived_units/spectral_intensity.hpp
index 37de7f83..6c463610 100644
--- a/include/mitama/dimensional/systems/si/derived_units/spectral_intensity.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/spectral_intensity.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "power.hpp"
 #include "solid_angle.hpp"
 
@@ -12,7 +12,7 @@ template<class> struct spectral_intensity_synonym{};
 using spectral_intensity_t = make_synonym_t<spectral_intensity_synonym, decltype( watt / steradian * meter<-1> )>;
 
 inline constexpr spectral_intensity_t spectral_intensity{};
-using spectral_intensity_r = make_refinement_symbol_t<spectral_intensity_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/spectral_irradiance.hpp b/include/mitama/dimensional/systems/si/derived_units/spectral_irradiance.hpp
index 47a05565..ab1c93c1 100644
--- a/include/mitama/dimensional/systems/si/derived_units/spectral_irradiance.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/spectral_irradiance.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "power.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct spectral_irradiance_synonym{};
 using spectral_irradiance_t = make_synonym_t<spectral_irradiance_synonym, decltype(watt / meter<3>)>;
 
 inline constexpr spectral_irradiance_t spectral_irradiance{};
-using spectral_irradiance_r = make_refinement_symbol_t<spectral_irradiance_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/spectral_power.hpp b/include/mitama/dimensional/systems/si/derived_units/spectral_power.hpp
index 79c89fd3..f50f8af1 100644
--- a/include/mitama/dimensional/systems/si/derived_units/spectral_power.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/spectral_power.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "power.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct spectral_power_synonym{};
 using spectral_power_t = make_synonym_t<spectral_power_synonym, decltype(watt / meter<>)>;
 
 inline constexpr spectral_power_t spectral_power{};
-using spectral_power_r = make_refinement_symbol_t<spectral_power_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/spectral_radiance.hpp b/include/mitama/dimensional/systems/si/derived_units/spectral_radiance.hpp
index 88663982..2f31f05d 100644
--- a/include/mitama/dimensional/systems/si/derived_units/spectral_radiance.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/spectral_radiance.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "power.hpp"
 #include "solid_angle.hpp"
 
@@ -12,7 +12,7 @@ template<class> struct spectral_radiance_synonym{};
 using spectral_radiance_t = make_synonym_t<spectral_radiance_synonym, decltype( watt / (steradian * meter<3>) )>;
 
 inline constexpr spectral_radiance_t spectral_radiance{};
-using spectral_radiance_r = make_refinement_symbol_t<spectral_radiance_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/stiffness.hpp b/include/mitama/dimensional/systems/si/derived_units/stiffness.hpp
index b60aa6d3..6d5aaac2 100644
--- a/include/mitama/dimensional/systems/si/derived_units/stiffness.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/stiffness.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "./force.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct stiffness_synonym{};
 using stiffness_t = make_synonym_t<stiffness_synonym, decltype(newton / meter<>)>;
 
 inline constexpr stiffness_t stiffness{};
-using stiffness_r = make_refinement_symbol_t<stiffness_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/surface_tension.hpp b/include/mitama/dimensional/systems/si/derived_units/surface_tension.hpp
index d361a3cc..012248be 100644
--- a/include/mitama/dimensional/systems/si/derived_units/surface_tension.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/surface_tension.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "force.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct surface_tension_synonym{};
 using surface_tension_t = make_synonym_t<surface_tension_synonym, decltype(newton / meter<>)>;
 
 inline constexpr surface_tension_t surface_tension{};
-using surface_tension_r = make_refinement_symbol_t<surface_tension_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/temperature_gradient.hpp b/include/mitama/dimensional/systems/si/derived_units/temperature_gradient.hpp
index c8a79164..8a81fd61 100644
--- a/include/mitama/dimensional/systems/si/derived_units/temperature_gradient.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/temperature_gradient.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct temperature_gradient_synonym{};
 using temperature_gradient_t = make_synonym_t<temperature_gradient_synonym, decltype(kelvin<> / meter<>)>;
 
 inline constexpr temperature_gradient_t temperature_gradient{};
-using temperature_gradient_r = make_refinement_symbol_t<temperature_gradient_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/thermal_conductivity.hpp b/include/mitama/dimensional/systems/si/derived_units/thermal_conductivity.hpp
index 235046c2..be0036e9 100644
--- a/include/mitama/dimensional/systems/si/derived_units/thermal_conductivity.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/thermal_conductivity.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "power.hpp"
 
 
@@ -12,7 +12,7 @@ template<class> struct thermal_conductivity_synonym{};
 using thermal_conductivity_t = make_synonym_t<thermal_conductivity_synonym, decltype( watt * meter<-1> * kelvin<-1> )>;
 
 inline constexpr thermal_conductivity_t thermal_conductivity{};
-using thermal_conductivity_r = make_refinement_symbol_t<thermal_conductivity_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/thermal_diffusivity.hpp b/include/mitama/dimensional/systems/si/derived_units/thermal_diffusivity.hpp
index 600287a8..a7cf2b8e 100644
--- a/include/mitama/dimensional/systems/si/derived_units/thermal_diffusivity.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/thermal_diffusivity.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -12,7 +12,7 @@ using thermal_diffusivity_t = make_synonym_t<thermal_diffusivity_synonym, declty
 
 #if !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_KINEMATIC_VISCOSITY_HPP) && !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_DIFFUSION_COEFFICIENT_HPP)
 inline constexpr thermal_diffusivity_t thermal_diffusivity{};
-using thermal_diffusivity_r = make_refinement_symbol_t<thermal_diffusivity_t>;
+
 #endif
 }
 
diff --git a/include/mitama/dimensional/systems/si/derived_units/thermal_expansion_coefficient.hpp b/include/mitama/dimensional/systems/si/derived_units/thermal_expansion_coefficient.hpp
index 1073f3ae..4d27697c 100644
--- a/include/mitama/dimensional/systems/si/derived_units/thermal_expansion_coefficient.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/thermal_expansion_coefficient.hpp
@@ -3,14 +3,14 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
 using thermal_expansion_coefficient_t = reciprocal_t<kelvin_t>;
 
 inline constexpr thermal_expansion_coefficient_t thermal_expansion_coefficient{};
-using thermal_expansion_coefficient_r = make_refinement_symbol_t<thermal_expansion_coefficient_t>;
+
 }
 
 #endif
diff --git a/include/mitama/dimensional/systems/si/derived_units/thermal_resistance.hpp b/include/mitama/dimensional/systems/si/derived_units/thermal_resistance.hpp
index 0eddf764..471ae2c2 100644
--- a/include/mitama/dimensional/systems/si/derived_units/thermal_resistance.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/thermal_resistance.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "power.hpp"
 
 
@@ -12,7 +12,7 @@ template<class> struct thermal_resistance_synonym{};
 using thermal_resistance_t = make_synonym_t<thermal_resistance_synonym, decltype(kelvin<> / watt)>;
 
 inline constexpr thermal_resistance_t thermal_resistance{};
-using thermal_resistance_r = make_refinement_symbol_t<thermal_resistance_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/torque.hpp b/include/mitama/dimensional/systems/si/derived_units/torque.hpp
index 4c722f8a..04a8e89a 100644
--- a/include/mitama/dimensional/systems/si/derived_units/torque.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/torque.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 #include "force.hpp"
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct torque_synonym{};
 using torque_t = make_synonym_t<torque_synonym, decltype(newton * meters)>;
 
 inline constexpr torque_t torque{};
-using torque_r = make_refinement_symbol_t<torque_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/velocity.hpp b/include/mitama/dimensional/systems/si/derived_units/velocity.hpp
index 38d64d36..964fc6b0 100644
--- a/include/mitama/dimensional/systems/si/derived_units/velocity.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/velocity.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct velocity_synonym{};
 using velocity_t = make_synonym_t<velocity_synonym, decltype(meters / seconds)>;
 
 inline constexpr velocity_t velocity{};
-using velocity_r = make_refinement_symbol_t<velocity_t>;
+
 }
 
 namespace mitama {
diff --git a/include/mitama/dimensional/systems/si/derived_units/voltage.hpp b/include/mitama/dimensional/systems/si/derived_units/voltage.hpp
index ae416c54..6e0ef28c 100644
--- a/include/mitama/dimensional/systems/si/derived_units/voltage.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/voltage.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -12,7 +12,7 @@ using voltage_t = make_synonym_t<voltage_synonym, decltype(kilogram<> * meter<2>
 
 #ifndef MITAMA_DIMENSIONAL_DERIVED_UNITS_ELECTRIC_POTENTIAL_HPP
 inline constexpr voltage_t volts{};
-using voltage_r = make_refinement_symbol_t<voltage_t>;
+
 template < std::intmax_t N >
 inline constexpr powered_t<voltage_t, N> volt{};
 #endif
diff --git a/include/mitama/dimensional/systems/si/derived_units/volume.hpp b/include/mitama/dimensional/systems/si/derived_units/volume.hpp
index 622fc0e9..a8cae823 100644
--- a/include/mitama/dimensional/systems/si/derived_units/volume.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/volume.hpp
@@ -3,14 +3,14 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
 using volume_t = powered_t<meter_t, 3>;
 
 inline constexpr volume_t volume{};
-using volume_r = make_refinement_symbol_t<volume_t>;
+
 }
 
 #endif
diff --git a/include/mitama/dimensional/systems/si/derived_units/volumetric_flow.hpp b/include/mitama/dimensional/systems/si/derived_units/volumetric_flow.hpp
index 25d8a38e..b5426ec2 100644
--- a/include/mitama/dimensional/systems/si/derived_units/volumetric_flow.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/volumetric_flow.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -11,7 +11,7 @@ template<class> struct volumetric_flow_synonym{};
 using volumetric_flow_t = make_synonym_t<volumetric_flow_synonym, decltype(meter<3> / second<>)>;
 
 inline constexpr volumetric_flow_t volumetric_flow{};
-using volumetric_flow_r = make_refinement_symbol_t<volumetric_flow_t>;
+
 }
 namespace mitama {
 template <> struct  abbreviation_<systems::si::volumetric_flow_t> { static constexpr char str[] = "m^3/s"; };
diff --git a/include/mitama/dimensional/systems/si/derived_units/wavenumber.hpp b/include/mitama/dimensional/systems/si/derived_units/wavenumber.hpp
index d9403348..3eda9d6c 100644
--- a/include/mitama/dimensional/systems/si/derived_units/wavenumber.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/wavenumber.hpp
@@ -3,14 +3,14 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
 using wavenumber_t = reciprocal_t<meter_t>;
 
 inline constexpr wavenumber_t wavenumber{};
-using wavenumber_r = make_refinement_symbol_t<wavenumber_t>;
+
 }
 
 #endif
diff --git a/include/mitama/dimensional/systems/si/derived_units/weight.hpp b/include/mitama/dimensional/systems/si/derived_units/weight.hpp
index f09bc3d0..5eb6b79c 100644
--- a/include/mitama/dimensional/systems/si/derived_units/weight.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/weight.hpp
@@ -3,14 +3,14 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 namespace mitama::systems::si {
 template<class> struct weight_synonym{};
 using weight_t = make_synonym_t<weight_synonym, decltype(kilogram<> * meter<> * second<-2>)>;
 #ifndef MITAMA_DIMENSIONAL_DERIVED_UNITS_FORCE_HPP
 inline constexpr weight_t newton{};
-using weight_r = make_refinement_symbol_t<weight_t>;
+
 #endif
 }
 
diff --git a/include/mitama/dimensional/systems/si/derived_units/work.hpp b/include/mitama/dimensional/systems/si/derived_units/work.hpp
index 2bca50d4..3a861974 100644
--- a/include/mitama/dimensional/systems/si/derived_units/work.hpp
+++ b/include/mitama/dimensional/systems/si/derived_units/work.hpp
@@ -3,7 +3,7 @@
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/io.hpp>
-#include <mitama/dimensional/refinement.hpp>
+
 
 
 namespace mitama::systems::si {
@@ -12,7 +12,7 @@ using work_t = make_synonym_t<work_synonym, decltype(kilogram<> * meter<2> * sec
 
 #if !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_ENERGY_HPP) && !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_HEAT_HPP)
 inline constexpr work_t joule{};
-using work_r = make_refinement_symbol_t<work_t>;
+
 #endif
 }
 
diff --git a/include/mitama/dimensional/systems/si/literals/all.hpp b/include/mitama/dimensional/systems/si/literals/all.hpp
new file mode 100644
index 00000000..97dc9265
--- /dev/null
+++ b/include/mitama/dimensional/systems/si/literals/all.hpp
@@ -0,0 +1,6 @@
+#ifndef MITAMA_DIMENSIONAL_SYSTEMS_SI_BASE_UNITS_LITERALS_ALL_HPP
+#define MITAMA_DIMENSIONAL_SYSTEMS_SI_BASE_UNITS_LITERALS_ALL_HPP
+#include <mitama/dimensional/systems/si/literals/ampere_literals.hpp>
+#include <mitama/dimensional/systems/si/literals/candela_literals.hpp>
+#include <mitama/dimensional/systems/si/literals/meter_literals.hpp>
+#endif
diff --git a/include/mitama/dimensional/systems/si/literals/ampere_literals.hpp b/include/mitama/dimensional/systems/si/literals/ampere_literals.hpp
new file mode 100644
index 00000000..fec1aafd
--- /dev/null
+++ b/include/mitama/dimensional/systems/si/literals/ampere_literals.hpp
@@ -0,0 +1,34 @@
+#ifndef MITAMA_DIMENSIONAL_SYSTEMS_SI_BASE_UNITS_LITERALS_AMPERE_LITERALS_HPP
+#define MITAMA_DIMENSIONAL_SYSTEMS_SI_BASE_UNITS_LITERALS_AMPERE_LITERALS_HPP
+#include <mitama/dimensional/systems/si/quantity.hpp>
+
+namespace mitama::literals {
+inline namespace units_literals {
+inline namespace si_literals {
+inline namespace electric_current_literals {
+    inline constexpr auto
+    operator"" _A(long double value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::ampere_t, long double>{value}; }
+
+    inline constexpr auto
+    operator"" _mA(long double value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::milliampere_t, long double>{value}; }
+
+    inline constexpr auto
+    operator"" _uA(long double value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::microampere_t, long double>{value}; }
+
+    inline constexpr auto
+    operator"" _nA(long double value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::nanoampere_t, long double>{value}; }
+
+    inline constexpr auto
+    operator"" _kA(long double value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::kiloampere_t, long double>{value}; }
+
+    inline constexpr auto
+    operator"" _MA(long double value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::megaampere_t, long double>{value}; }
+
+}}}}
+#endif
diff --git a/include/mitama/dimensional/systems/si/literals/candela_literals.hpp b/include/mitama/dimensional/systems/si/literals/candela_literals.hpp
new file mode 100644
index 00000000..98fe4143
--- /dev/null
+++ b/include/mitama/dimensional/systems/si/literals/candela_literals.hpp
@@ -0,0 +1,20 @@
+#ifndef MITAMA_DIMENSIONAL_SYSTEMS_SI_BASE_UNITS_LITERALS_CANDELA_LITERALS_HPP
+#define MITAMA_DIMENSIONAL_SYSTEMS_SI_BASE_UNITS_LITERALS_CANDELA_LITERALS_HPP
+#include <mitama/dimensional/systems/si/quantity.hpp>
+
+namespace mitama::literals {
+inline namespace units_literals {
+inline namespace si_literals {
+inline namespace luminous_intesity_literals {
+    inline constexpr auto
+    operator"" _cd(long double value)
+    -> mitama::systems::si::quantity_t<mitama::systems::si::candela_t, long double>
+    { return {value}; }
+
+    inline constexpr auto
+    operator"" _mcd(long double value)
+    -> mitama::systems::si::quantity_t<mitama::systems::si::millicandela_t, long double>
+    { return {value}; }
+
+}}}}
+#endif
diff --git a/include/mitama/dimensional/systems/si/literals/meter_literals.hpp b/include/mitama/dimensional/systems/si/literals/meter_literals.hpp
new file mode 100644
index 00000000..eb636232
--- /dev/null
+++ b/include/mitama/dimensional/systems/si/literals/meter_literals.hpp
@@ -0,0 +1,161 @@
+#ifndef MITAMA_DIMENSIONAL_SYSTEMS_SI_BASE_UNITS_LITERALS_METER_LITERALS_HPP
+#define MITAMA_DIMENSIONAL_SYSTEMS_SI_BASE_UNITS_LITERALS_METER_LITERALS_HPP
+#include <mitama/dimensional/systems/si/quantity.hpp>
+
+namespace mitama::literals {
+inline namespace units_literals {
+inline namespace si_literals {
+inline namespace length_literals {
+namespace long_double_literals {
+    inline constexpr auto
+    operator"" _m(long double value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::meter_t, long double>{value}; }
+
+    inline constexpr auto
+    operator"" _dm(long double value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::decimeter_t, long double>{value}; }
+
+    inline constexpr auto
+    operator"" _cm(long double value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::centimeter_t, long double>{value}; }
+
+    inline constexpr auto
+    operator"" _mm(long double value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::millimeter_t, long double>{value}; }
+
+    inline constexpr auto
+    operator"" _um(long double value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::micrometer_t, long double>{value}; }
+
+    inline constexpr auto
+    operator"" _nm(long double value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::nanometer_t, long double>{value}; }
+
+    inline constexpr auto
+    operator"" _pm(long double value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::picometer_t, long double>{value}; }
+
+    inline constexpr auto
+    operator"" _km(long double value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::kilometer_t, long double>{value}; }
+
+    inline constexpr auto
+    operator"" _Mm(long double value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::megameter_t, long double>{value}; }
+}
+inline namespace double_literals {
+    inline constexpr auto
+    operator"" _m(long double value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::meter_t, double>{value}; }
+
+    inline constexpr auto
+    operator"" _dm(long double value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::decimeter_t, double>{value}; }
+
+    inline constexpr auto
+    operator"" _cm(long double value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::centimeter_t, double>{value}; }
+
+    inline constexpr auto
+    operator"" _mm(long double value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::millimeter_t, double>{value}; }
+
+    inline constexpr auto
+    operator"" _um(long double value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::micrometer_t, double>{value}; }
+
+    inline constexpr auto
+    operator"" _nm(long double value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::nanometer_t, double>{value}; }
+
+    inline constexpr auto
+    operator"" _pm(long double value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::picometer_t, double>{value}; }
+
+    inline constexpr auto
+    operator"" _km(long double value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::kilometer_t, double>{value}; }
+
+    inline constexpr auto
+    operator"" _Mm(long double value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::megameter_t, double>{value}; }
+}
+
+namespace unsigned_long_long_literals {
+    inline constexpr auto
+    operator"" _m(unsigned long long value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::meter_t, unsigned long long>{value}; }
+
+    inline constexpr auto
+    operator"" _dm(unsigned long long value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::decimeter_t, unsigned long long>{value}; }
+
+    inline constexpr auto
+    operator"" _cm(unsigned long long value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::centimeter_t, unsigned long long>{value}; }
+
+    inline constexpr auto
+    operator"" _mm(unsigned long long value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::millimeter_t, unsigned long long>{value}; }
+
+    inline constexpr auto
+    operator"" _um(unsigned long long value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::micrometer_t, unsigned long long>{value}; }
+
+    inline constexpr auto
+    operator"" _nm(unsigned long long value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::nanometer_t, unsigned long long>{value}; }
+
+    inline constexpr auto
+    operator"" _pm(unsigned long long value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::picometer_t, unsigned long long>{value}; }
+
+    inline constexpr auto
+    operator"" _km(unsigned long long value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::kilometer_t, unsigned long long>{value}; }
+
+    inline constexpr auto
+    operator"" _Mm(unsigned long long value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::megameter_t, unsigned long long>{value}; }
+}
+
+inline namespace int_literals {
+    inline constexpr auto
+    operator"" _m(unsigned long long value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::meter_t, int>{value}; }
+
+    inline constexpr auto
+    operator"" _dm(unsigned long long value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::decimeter_t, int>{value}; }
+
+    inline constexpr auto
+    operator"" _cm(unsigned long long value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::centimeter_t, int>{value}; }
+
+    inline constexpr auto
+    operator"" _mm(unsigned long long value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::millimeter_t, int>{value}; }
+
+    inline constexpr auto
+    operator"" _um(unsigned long long value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::micrometer_t, int>{value}; }
+
+    inline constexpr auto
+    operator"" _nm(unsigned long long value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::nanometer_t, int>{value}; }
+
+    inline constexpr auto
+    operator"" _pm(unsigned long long value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::picometer_t, int>{value}; }
+
+    inline constexpr auto
+    operator"" _km(unsigned long long value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::kilometer_t, int>{value}; }
+
+    inline constexpr auto
+    operator"" _Mm(unsigned long long value)
+    { return mitama::systems::si::quantity_t<mitama::systems::si::megameter_t, int>{value}; }
+}
+
+}}}}
+#endif
diff --git a/include/mitama/dimensional/systems/si/quantity.hpp b/include/mitama/dimensional/systems/si/quantity.hpp
index 309710ce..418fa897 100644
--- a/include/mitama/dimensional/systems/si/quantity.hpp
+++ b/include/mitama/dimensional/systems/si/quantity.hpp
@@ -1,26 +1,12 @@
 #ifndef MITAMA_DIMENSIONAL_SYSTEMS_SI_QUANTITY_HPP
 #define MITAMA_DIMENSIONAL_SYSTEMS_SI_QUANTITY_HPP
 #include <mitama/dimensional/quantity.hpp>
-#include <mitama/dimensional/system.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/angle.hpp>
-#include <mitama/dimensional/systems/si/derived_units/solid_angle.hpp>
+#include <mitama/dimensional/systems/si/base_units/fwd/si_base_units.hpp>
 
 namespace mitama::systems::si {
-  template < class D, typename T > 
+  template < class D, typename T = double > 
   using quantity_t
-    = ::mitama::quantity_t<D, T,
-        ::mitama::system<
-          ampere_t,
-          luminous_intensity,
-          thermodynamic_temperature,
-          mass,
-          length,
-          amount_of_substance,
-          time,
-          angle,
-          solid_angle
-    >>;
+    = ::mitama::quantity_t<D, T, ::mitama::systems::si::system>;
 }
 
 #endif // !MITAMA_DIMENSIONAL_SYSTEMS_SI_QUANTITY_HPP
diff --git a/include/mitama/dimensional/systems/si/units_system/system.hpp b/include/mitama/dimensional/systems/si/units_system/system.hpp
deleted file mode 100644
index b3b21b8c..00000000
--- a/include/mitama/dimensional/systems/si/units_system/system.hpp
+++ /dev/null
@@ -1,9 +0,0 @@
-#ifndef MITAMA_DIMENSIONAL_SYSTEMS_SI_UNITS_SYSTEMS_HPP
-#define MITAMA_DIMENSIONAL_SYSTEMS_SI_UNITS_SYSTEMS_HPP
-#include <mitama/dimensional/system.hpp>
-
-namespace mitama::systems::si {
-    using units_system = ::mitama::system<>;
-}
-
-#endif
diff --git a/mitama-cpp-result b/mitama-cpp-result
index fa3a9339..5fdd707f 160000
--- a/mitama-cpp-result
+++ b/mitama-cpp-result
@@ -1 +1 @@
-Subproject commit fa3a9339812d7bfe9c80c10c0c7ba4b76e44d27c
+Subproject commit 5fdd707ff0d3f19c671167b61df805329ff40451
diff --git a/mitama_build.sh b/mitama_build.sh
index f0b8925f..b96b20c4 100755
--- a/mitama_build.sh
+++ b/mitama_build.sh
@@ -8,11 +8,12 @@ set(CMAKE_CXX_STANDARD 17) # ...C++17
 set(CMAKE_CXX_STANDARD_REQUIRED ON) #...is required...
 set(CMAKE_CXX_EXTENSIONS OFF) #...without compiler extensions like gnu++17
 find_package(Threads REQUIRED)
-
+find_package(Boost 1.62.0 REQUIRED)
 ## Set our project name
 project(mitama-dimensional)
 
 include_directories(
+  PUBLIC ${Boost_INCLUDE_DIRS}
   PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/tests
   PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include
   PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/mitama-cpp-result/include
@@ -38,4 +39,4 @@ mkdir -p build \
     && cd build \
     && cmake .. \
     && make -j5 \
-    && ctest 2>&1 | tee ./ctset.log
\ No newline at end of file
+    && ctest 2>&1 | tee ./ctset.log
diff --git a/tests/arithmetic-tests/division-tests/division-tests.cpp b/tests/arithmetic-tests/division-tests/division-tests.cpp
index 59582028..7c3d2178 100644
--- a/tests/arithmetic-tests/division-tests/division-tests.cpp
+++ b/tests/arithmetic-tests/division-tests/division-tests.cpp
@@ -10,8 +10,8 @@ TEMPLATE_TEST_CASE("meter_t division",
     REQUIRE(
         std::is_same_v<std::decay_t<decltype(a/b)>,
         quantity_t<si_base_units<dimensional_t<
-            units_t<0, length, std::ratio<1>, std::ratio<1>>,
-            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<-1>, std::ratio<1>>
+            units_t<0, length, std::ratio<1>, std::ratio<1>, mitama::systems::si::system>,
+            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<-1>, std::ratio<1>, mitama::systems::si::system>
         >>, double>>);
 }
 
@@ -26,8 +26,8 @@ TEMPLATE_TEST_CASE("ampere_t division",
     REQUIRE(
         std::is_same_v<std::decay_t<decltype(a/b)>,
         quantity_t<si_base_units<dimensional_t<
-            units_t<0, electric_current, std::ratio<1>, std::ratio<1>>,
-            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<-1>, std::ratio<1>>
+            units_t<0, electric_current, std::ratio<1>, std::ratio<1>, mitama::systems::si::system>,
+            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<-1>, std::ratio<1>, mitama::systems::si::system>
         >>, double>>);
 }
 
@@ -42,8 +42,8 @@ TEMPLATE_TEST_CASE("candela_t division",
     REQUIRE(
         std::is_same_v<std::decay_t<decltype(a/b)>,
         quantity_t<si_base_units<dimensional_t<
-            units_t<0, luminous_intensity, std::ratio<1>, std::ratio<1>>,
-            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<-1>, std::ratio<1>>
+            units_t<0, luminous_intensity, std::ratio<1>, std::ratio<1>, mitama::systems::si::system>,
+            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<-1>, std::ratio<1>, mitama::systems::si::system>
         >>, double>>);
 }
 
@@ -58,8 +58,8 @@ TEMPLATE_TEST_CASE("kelvin_t division",
     REQUIRE(
         std::is_same_v<std::decay_t<decltype(a/b)>,
         quantity_t<si_base_units<dimensional_t<
-            units_t<0, thermodynamic_temperature, std::ratio<1>, std::ratio<1>>,
-            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<-1>, std::ratio<1>>
+            units_t<0, thermodynamic_temperature, std::ratio<1>, std::ratio<1>, mitama::systems::si::system>,
+            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<-1>, std::ratio<1>, mitama::systems::si::system>
         >>, double>>);
 }
 
@@ -74,8 +74,8 @@ TEMPLATE_TEST_CASE("kilogram_t division",
     REQUIRE(
         std::is_same_v<std::decay_t<decltype(a/b)>,
         quantity_t<si_base_units<dimensional_t<
-            units_t<0, mass, std::ratio<1>, std::ratio<1>>,
-            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<-1>, std::ratio<1>>
+            units_t<0, mass, std::ratio<1>, std::ratio<1>, mitama::systems::si::system>,
+            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<-1>, std::ratio<1>, mitama::systems::si::system>
         >>, double>>);
 }
 
@@ -90,8 +90,8 @@ TEMPLATE_TEST_CASE("mol_t division",
     REQUIRE(
         std::is_same_v<std::decay_t<decltype(a/b)>,
         quantity_t<si_base_units<dimensional_t<
-            units_t<0, amount_of_substance, std::ratio<1>, std::ratio<1>>,
-            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<-1>, std::ratio<1>>
+            units_t<0, amount_of_substance, std::ratio<1>, std::ratio<1>, mitama::systems::si::system>,
+            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<-1>, std::ratio<1>, mitama::systems::si::system>
         >>, double>>);
 }
 
@@ -106,8 +106,8 @@ TEMPLATE_TEST_CASE("second_t division",
     REQUIRE(
         std::is_same_v<std::decay_t<decltype(a/b)>,
         quantity_t<si_base_units<dimensional_t<
-            units_t<0, mitama::systems::si::time, std::ratio<1>, std::ratio<1>>,
-            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<-1>, std::ratio<1>>
+            units_t<0, mitama::systems::si::time, std::ratio<1>, std::ratio<1>, mitama::systems::si::system>,
+            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<-1>, std::ratio<1>, mitama::systems::si::system>
         >>, double>>);
 }
 
diff --git a/tests/arithmetic-tests/multiply-tests/multiply-tests.cpp b/tests/arithmetic-tests/multiply-tests/multiply-tests.cpp
index 815667a3..6c7ab8d0 100644
--- a/tests/arithmetic-tests/multiply-tests/multiply-tests.cpp
+++ b/tests/arithmetic-tests/multiply-tests/multiply-tests.cpp
@@ -9,8 +9,8 @@ TEMPLATE_TEST_CASE("meter_t multiply",
     REQUIRE(
         std::is_same_v<std::decay_t<decltype(a*b)>,
         quantity_t<si_base_units<dimensional_t<
-            units_t<0, length, std::ratio<1>, std::ratio<1>>,
-            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<1>, std::ratio<1>>
+            units_t<0, length, std::ratio<1>, std::ratio<1>, mitama::systems::si::system>,
+            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<1>, std::ratio<1>, mitama::systems::si::system>
         >>, int>>);
 }
 
@@ -24,8 +24,8 @@ TEMPLATE_TEST_CASE("ampere_t multiply",
     REQUIRE(
         std::is_same_v<std::decay_t<decltype(a*b)>,
         quantity_t<si_base_units<dimensional_t<
-            units_t<0, electric_current, std::ratio<1>, std::ratio<1>>,
-            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<1>, std::ratio<1>>
+            units_t<0, electric_current, std::ratio<1>, std::ratio<1>, mitama::systems::si::system>,
+            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<1>, std::ratio<1>, mitama::systems::si::system>
         >>, int>>);
 }
 
@@ -39,8 +39,8 @@ TEMPLATE_TEST_CASE("candela_t multiply",
     REQUIRE(
         std::is_same_v<std::decay_t<decltype(a*b)>,
         quantity_t<si_base_units<dimensional_t<
-            units_t<0, luminous_intensity, std::ratio<1>, std::ratio<1>>,
-            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<1>, std::ratio<1>>
+            units_t<0, luminous_intensity, std::ratio<1>, std::ratio<1>, mitama::systems::si::system>,
+            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<1>, std::ratio<1>, mitama::systems::si::system>
         >>, int>>);
 }
 
@@ -54,8 +54,8 @@ TEMPLATE_TEST_CASE("kelvin_t multiply",
     REQUIRE(
         std::is_same_v<std::decay_t<decltype(a*b)>,
         quantity_t<si_base_units<dimensional_t<
-            units_t<0, thermodynamic_temperature, std::ratio<1>, std::ratio<1>>,
-            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<1>, std::ratio<1>>
+            units_t<0, thermodynamic_temperature, std::ratio<1>, std::ratio<1>, mitama::systems::si::system>,
+            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<1>, std::ratio<1>, mitama::systems::si::system>
         >>, int>>);
 }
 
@@ -69,8 +69,8 @@ TEMPLATE_TEST_CASE("kilogram_t multiply",
     REQUIRE(
         std::is_same_v<std::decay_t<decltype(a*b)>,
         quantity_t<si_base_units<dimensional_t<
-            units_t<0, mass, std::ratio<1>, std::ratio<1>>,
-            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<1>, std::ratio<1>>
+            units_t<0, mass, std::ratio<1>, std::ratio<1>, mitama::systems::si::system>,
+            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<1>, std::ratio<1>, mitama::systems::si::system>
         >>, int>>);
 }
 
@@ -84,8 +84,8 @@ TEMPLATE_TEST_CASE("mol_t multiply",
     REQUIRE(
         std::is_same_v<std::decay_t<decltype(a*b)>,
         quantity_t<si_base_units<dimensional_t<
-            units_t<0, amount_of_substance, std::ratio<1>, std::ratio<1>>,
-            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<1>, std::ratio<1>>
+            units_t<0, amount_of_substance, std::ratio<1>, std::ratio<1>, mitama::systems::si::system>,
+            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<1>, std::ratio<1>, mitama::systems::si::system>
         >>, int>>);
 }
 
@@ -99,8 +99,8 @@ TEMPLATE_TEST_CASE("second_t multiply",
     REQUIRE(
         std::is_same_v<std::decay_t<decltype(a*b)>,
         quantity_t<si_base_units<dimensional_t<
-            units_t<0, mitama::systems::si::time, std::ratio<1>, std::ratio<1>>,
-            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<1>, std::ratio<1>>
+            units_t<0, mitama::systems::si::time, std::ratio<1>, std::ratio<1>, mitama::systems::si::system>,
+            units_t<0, typename basis_<TestType>::template type<0>, std::ratio<1>, std::ratio<1>, mitama::systems::si::system>
         >>, int>>);
 }
 
diff --git a/tests/basic-tests/CMakeLists.txt b/tests/basic-tests/CMakeLists.txt
index a03569c8..39bdda73 100644
--- a/tests/basic-tests/CMakeLists.txt
+++ b/tests/basic-tests/CMakeLists.txt
@@ -3,7 +3,7 @@ message(STATUS "Building basic test")
 set(target basic-tests)
 message(STATUS "Building library ${target}")
 
-set(sources basic-tests.cpp tests-main.cpp)
+set(sources basic-tests.cpp relationals.cpp tests-main.cpp)
 
 add_executable(${target} ${sources})
 add_test(basic "${EXECUTABLE_OUTPUT_PATH}/${target}")
diff --git a/tests/basic-tests/basic-tests.cpp b/tests/basic-tests/basic-tests.cpp
index 3fc4ea05..28e370e3 100644
--- a/tests/basic-tests/basic-tests.cpp
+++ b/tests/basic-tests/basic-tests.cpp
@@ -3,33 +3,31 @@
 #include <mitama/dimensional/quantity.hpp>
 #include <mitama/dimensional/systems/si/all.hpp>
 #include <mitama/dimensional/systems/si/prefix.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include <mitama/dimensional/arithmetic.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <mitama/dimensional/systems/nonsi/minute.hpp>
-#include <mitama/dimensional/systems/nonsi/hour.hpp>
-#include <mitama/dimensional/systems/nonsi/day.hpp>
+
 #include <test_util.hpp>
 
 using namespace mitama;
-using namespace mitama::systems::si;
-using namespace mitama::systems::nonsi;
+namespace si = mitama::systems::si;
+namespace nonsi = mitama::systems::nonsi;
 
 TEMPLATE_TEST_CASE("constructor from values",
                    "[quantity][constructor]",
-                   meter_t, ampere_t, candela_t, kelvin_t, kilogram_t, mol_t, second_t)
+                   si::meter_t, si::ampere_t, si::candela_t, si::kelvin_t, si::kilogram_t, si::mol_t, si::second_t)
 {
-    quantity_t<TestType, int> a(1);
-    REQUIRE( a.value() == 1 );
+    si::quantity_t<TestType, int> a(1);
+    REQUIRE( a == (1|TestType{}) );
 
-    quantity_t<scaled_unit_t<TestType, std::milli>, double> b = a;
+    si::quantity_t<scaled_unit_t<TestType, std::milli>, double> b = a;
     REQUIRE( b.value() == 1000 );
 }
 
 TEMPLATE_TEST_CASE("validates",
                    "[quantity][validate]",
-                   second_t, meter_t, ampere_t, candela_t, kelvin_t, kilogram_t, mol_t)
+                   si::meter_t, si::ampere_t, si::candela_t, si::kelvin_t, si::kilogram_t, si::mol_t, si::second_t)
 {
-    auto validator = [](auto v) -> mitama::result<quantity_t<TestType, int>, int> {
+    auto validator = [](auto v) -> mitama::result<si::quantity_t<TestType, int>, int> {
         if (v.value() < 0)
             return mitama::failure(v.value());
         else
@@ -43,7 +41,7 @@ TEMPLATE_TEST_CASE("validates",
 #include <mitama/dimensional/systems/si/quantity.hpp>
 
 TEMPLATE_TEST_CASE("si-quantity; constructor from values","[quantity][constructor]",
-  meter_t, ampere_t, candela_t, kelvin_t, kilogram_t, mol_t, second_t)
+                   si::meter_t, si::ampere_t, si::candela_t, si::kelvin_t, si::kilogram_t, si::mol_t, si::second_t)
 {
   systems::si::quantity_t<TestType, int> a(1);
   REQUIRE(a.value() == 1);
diff --git a/tests/basic-tests/relationals.cpp b/tests/basic-tests/relationals.cpp
new file mode 100644
index 00000000..4452543e
--- /dev/null
+++ b/tests/basic-tests/relationals.cpp
@@ -0,0 +1,124 @@
+// main is provided in tests-main.cpp
+#include <catch2/catch.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
+#include <mitama/dimensional/arithmetic.hpp>
+#include <mitama/dimensional/systems/si/prefix.hpp>
+#include <test_util.hpp>
+
+using namespace mitama;
+namespace si = mitama::systems::si;
+
+TEMPLATE_TEST_CASE("equal",
+                   "[quantity][relationals]",
+                   si::meter_t, si::ampere_t, si::candela_t, si::kelvin_t, si::kilogram_t, si::mol_t, si::second_t)
+{
+    si::quantity_t<TestType, int> a(1);
+    si::quantity_t<TestType, int> b(1);
+    si::quantity_t<TestType, int> c(2);
+    REQUIRE( a == a );
+    REQUIRE( a == b );
+    REQUIRE( b == a );
+    REQUIRE_FALSE( a == c );
+    REQUIRE_FALSE( c == a );
+    REQUIRE( a + b == c );
+    REQUIRE( c - a == b );
+    REQUIRE( (a * c).value() == c.value() );
+    REQUIRE( (c / b).value() == c.value() );
+}
+
+TEMPLATE_TEST_CASE("equal with different scales",
+                   "[quantity][relationals]",
+                   si::meter_t, si::ampere_t, si::candela_t, si::kelvin_t, si::kilogram_t, si::mol_t, si::second_t)
+{
+    si::quantity_t<decltype(si::milli * TestType{}), int> a(1);
+    si::quantity_t<decltype(si::milli * TestType{}), int> b(1000);
+    si::quantity_t<TestType, int> c(1);
+    REQUIRE_FALSE( a == b );
+    REQUIRE_FALSE( b == a );
+    REQUIRE( b == c );
+    REQUIRE( c == b );
+}
+
+TEMPLATE_TEST_CASE("less",
+                   "[quantity][relationals]",
+                   si::meter_t, si::ampere_t, si::candela_t, si::kelvin_t, si::kilogram_t, si::mol_t, si::second_t)
+{
+    si::quantity_t<TestType, int> a(1);
+    si::quantity_t<TestType, int> b(2);
+    REQUIRE( a < b );
+    REQUIRE_FALSE( a < a );
+    REQUIRE_FALSE( b < a );
+}
+
+TEMPLATE_TEST_CASE("less with different scales",
+                   "[quantity][relationals]",
+                   si::meter_t, si::ampere_t, si::candela_t, si::kelvin_t, si::kilogram_t, si::mol_t, si::second_t)
+{
+    si::quantity_t<decltype(si::milli * TestType{}), int> a(1);
+    si::quantity_t<TestType, int> b(1);
+    REQUIRE( a < b );
+    REQUIRE_FALSE( b < a );
+}
+
+TEMPLATE_TEST_CASE("greater",
+                   "[quantity][relationals]",
+                   si::meter_t, si::ampere_t, si::candela_t, si::kelvin_t, si::kilogram_t, si::mol_t, si::second_t)
+{
+    si::quantity_t<TestType, int> a(1);
+    si::quantity_t<TestType, int> b(2);
+    REQUIRE_FALSE( a > b );
+    REQUIRE_FALSE( a > a );
+    REQUIRE( b > a );
+}
+
+TEMPLATE_TEST_CASE("greater with different scales",
+                   "[quantity][relationals]",
+                   si::meter_t, si::ampere_t, si::candela_t, si::kelvin_t, si::kilogram_t, si::mol_t, si::second_t)
+{
+    si::quantity_t<decltype(si::milli * TestType{}), int> a(1);
+    si::quantity_t<TestType, int> b(1);
+    REQUIRE_FALSE( a > b );
+    REQUIRE( b > a );
+}
+
+TEMPLATE_TEST_CASE("less or equal",
+                   "[quantity][relationals]",
+                   si::meter_t, si::ampere_t, si::candela_t, si::kelvin_t, si::kilogram_t, si::mol_t, si::second_t)
+{
+    si::quantity_t<TestType, int> a(1);
+    si::quantity_t<TestType, int> b(2);
+    REQUIRE( a <= b );
+    REQUIRE( a <= a );
+    REQUIRE_FALSE( b <= a );
+}
+
+TEMPLATE_TEST_CASE("less or equal with different scales",
+                   "[quantity][relationals]",
+                   si::meter_t, si::ampere_t, si::candela_t, si::kelvin_t, si::kilogram_t, si::mol_t, si::second_t)
+{
+    si::quantity_t<decltype(si::milli * TestType{}), int> a(1);
+    si::quantity_t<TestType, int> b(1);
+    REQUIRE( a <= b );
+    REQUIRE_FALSE( b <= a );
+}
+
+TEMPLATE_TEST_CASE("greater or equal",
+                   "[quantity][relationals]",
+                   si::meter_t, si::ampere_t, si::candela_t, si::kelvin_t, si::kilogram_t, si::mol_t, si::second_t)
+{
+    si::quantity_t<TestType, int> a(1);
+    si::quantity_t<TestType, int> b(2);
+    REQUIRE_FALSE( a >= b );
+    REQUIRE( a >= a );
+    REQUIRE( b >= a );
+}
+
+TEMPLATE_TEST_CASE("greater or equal with different scales",
+                   "[quantity][relationals]",
+                   si::meter_t, si::ampere_t, si::candela_t, si::kelvin_t, si::kilogram_t, si::mol_t, si::second_t)
+{
+    si::quantity_t<decltype(si::milli * TestType{}), int> a(1);
+    si::quantity_t<TestType, int> b(1);
+    REQUIRE_FALSE( a >= b );
+    REQUIRE( b >= a );
+}
diff --git a/tests/derived-unit-tests/derived-unit-tests.cpp b/tests/derived-unit-tests/derived-unit-tests.cpp
index 9bcf4c6d..10e00e9d 100644
--- a/tests/derived-unit-tests/derived-unit-tests.cpp
+++ b/tests/derived-unit-tests/derived-unit-tests.cpp
@@ -6,7 +6,6 @@
 #include <mitama/dimensional/systems/si/prefix.hpp>
 #include <random>
 #include <test_util.hpp>
-#include <mitama/dimensional/expr.hpp>
 #include <mitama/dimensional/arithmetic.hpp>
 
 using namespace mitama;
@@ -46,18 +45,3 @@ TEST_CASE("degree celsius and kelvin generate tests",
                 return s.value() - c.value() == 273.15_a;
             }));
 }
-
-TEST_CASE("degree celsius and kelvin lexical tests",
-          "[quantity][derived-units][temperature]")
-{
-    using namespace Catch::literals;
-    {
-        quantity_t<decltype(kelvin<>/mol<>)> _ = as_expr(1|kelvins) / (2|mols) + as_expr(2|degree_celsius) / (2|mols);
-        REQUIRE(_.value() == 137.575_a);
-    }
-    {
-        quantity_t<decltype(kelvin<>/mol<>)> _ = (as_expr(11|kelvins) - as_expr(1|kelvins)) / (2|mols) + (as_expr(21|degree_celsius) - as_expr(1|degree_celsius)) / (2|mols);
-        REQUIRE(_.value() == 15._a);
-    }
-}
-
diff --git a/tests/format-io-tests/absorbed_dose-tests/absorbed_dose-tests.cpp b/tests/format-io-tests/absorbed_dose-tests/absorbed_dose-tests.cpp
index 6e16f0a5..5c357c0b 100644
--- a/tests/format-io-tests/absorbed_dose-tests/absorbed_dose-tests.cpp
+++ b/tests/format-io-tests/absorbed_dose-tests/absorbed_dose-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/absorbed_dose.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("sievert_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/absorbed_dose_rate-tests/absorbed_dose_rate-tests.cpp b/tests/format-io-tests/absorbed_dose_rate-tests/absorbed_dose_rate-tests.cpp
index 9c56e719..e8470125 100644
--- a/tests/format-io-tests/absorbed_dose_rate-tests/absorbed_dose_rate-tests.cpp
+++ b/tests/format-io-tests/absorbed_dose_rate-tests/absorbed_dose_rate-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/absorbed_dose_rate.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("absorbed_dose_rate format test", "[quantity][abbreviation]") {
@@ -10,5 +11,7 @@ TEST_CASE("absorbed_dose_rate quantifier format test", "[quantity][abbreviation]
   REQUIRE(fmt(1 | systems::si::absorbed_dose_rate) == "1 [Gy/s]");
 }
 TEST_CASE("absorbed_dose_rate type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::absorbed_dose_rate)>, mitama::quantity_t<std::decay_t<decltype(meter<2>*second<-3>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<
+    std::decay_t<decltype(1|systems::si::absorbed_dose_rate)>,
+    mitama::systems::si::quantity_t<std::decay_t<decltype(meter<2>*second<-3>)>>>);
 }
diff --git a/tests/format-io-tests/acceleration-tests/acceleration-tests.cpp b/tests/format-io-tests/acceleration-tests/acceleration-tests.cpp
index 22a7a590..8e771437 100644
--- a/tests/format-io-tests/acceleration-tests/acceleration-tests.cpp
+++ b/tests/format-io-tests/acceleration-tests/acceleration-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/acceleration.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("acceleration format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("acceleration quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::acceleration) == "1 [m/s^2]");
 }
 TEST_CASE("acceleration type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::acceleration)>, mitama::quantity_t<std::decay_t<decltype(meters/second<2>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::acceleration)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meters/second<2>)>>>);
 }
diff --git a/tests/format-io-tests/action-tests/action-tests.cpp b/tests/format-io-tests/action-tests/action-tests.cpp
index 89e625bf..55e19af8 100644
--- a/tests/format-io-tests/action-tests/action-tests.cpp
+++ b/tests/format-io-tests/action-tests/action-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/action.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("action format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("action quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::action) == "1 [J s]");
 }
 TEST_CASE("action type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::action)>, mitama::quantity_t<std::decay_t<decltype(meter<2>*kilograms*second<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::action)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<2>*kilograms*second<-1>)>>>);
 }
diff --git a/tests/format-io-tests/angle-tests/angle-tests.cpp b/tests/format-io-tests/angle-tests/angle-tests.cpp
index b2e9ec9a..bc7fb008 100644
--- a/tests/format-io-tests/angle-tests/angle-tests.cpp
+++ b/tests/format-io-tests/angle-tests/angle-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/angle.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("radian_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/angular_acceleration-tests/angular_acceleration-tests.cpp b/tests/format-io-tests/angular_acceleration-tests/angular_acceleration-tests.cpp
index 699e34ff..1c0d32ff 100644
--- a/tests/format-io-tests/angular_acceleration-tests/angular_acceleration-tests.cpp
+++ b/tests/format-io-tests/angular_acceleration-tests/angular_acceleration-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/angular_acceleration.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("angular_acceleration format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("angular_acceleration quantifier format test", "[quantity][abbreviatio
   REQUIRE(fmt(1 | systems::si::angular_acceleration) == "1 [rad/s^2]");
 }
 TEST_CASE("angular_acceleration type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::angular_acceleration)>, mitama::quantity_t<std::decay_t<decltype(radian*second<-2>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::angular_acceleration)>, mitama::systems::si::quantity_t<std::decay_t<decltype(radian*second<-2>)>>>);
 }
diff --git a/tests/format-io-tests/angular_momentum-tests/angular_momentum-tests.cpp b/tests/format-io-tests/angular_momentum-tests/angular_momentum-tests.cpp
index ef9f62d0..34b5920b 100644
--- a/tests/format-io-tests/angular_momentum-tests/angular_momentum-tests.cpp
+++ b/tests/format-io-tests/angular_momentum-tests/angular_momentum-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/angular_momentum.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("angular_momentum format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("angular_momentum quantifier format test", "[quantity][abbreviation]")
   REQUIRE(fmt(1 | systems::si::angular_momentum) == "1 [N m s]");
 }
 TEST_CASE("angular_momentum type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::angular_momentum)>, mitama::quantity_t<std::decay_t<decltype(meter<2>*kilograms*second<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::angular_momentum)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<2>*kilograms*second<-1>)>>>);
 }
diff --git a/tests/format-io-tests/angular_velocity-tests/angular_velocity-tests.cpp b/tests/format-io-tests/angular_velocity-tests/angular_velocity-tests.cpp
index 68c7d345..c5fc86c7 100644
--- a/tests/format-io-tests/angular_velocity-tests/angular_velocity-tests.cpp
+++ b/tests/format-io-tests/angular_velocity-tests/angular_velocity-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/angular_velocity.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("angular_velocity format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("angular_velocity quantifier format test", "[quantity][abbreviation]")
   REQUIRE(fmt(1 | systems::si::angular_velocity) == "1 [rad/s]");
 }
 TEST_CASE("angular_velocity type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::angular_velocity)>, mitama::quantity_t<std::decay_t<decltype(radian*second<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::angular_velocity)>, mitama::systems::si::quantity_t<std::decay_t<decltype(radian*second<-1>)>>>);
 }
diff --git a/tests/format-io-tests/area-tests/area-tests.cpp b/tests/format-io-tests/area-tests/area-tests.cpp
index 5d1508c1..e8cfde2a 100644
--- a/tests/format-io-tests/area-tests/area-tests.cpp
+++ b/tests/format-io-tests/area-tests/area-tests.cpp
@@ -1,14 +1,12 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/area.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
-TEST_CASE("area format test", "[quantity][abbreviation]") {
-  REQUIRE(fmt(accepts<area_r> |= 1 | systems::si::area_t{}) == "1 [m^2]");
-}
 TEST_CASE("area quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::area) == "1 [m^2]");
 }
 TEST_CASE("area type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::area)>, mitama::quantity_t<std::decay_t<decltype(meter<2>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::area)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<2>)>>>);
 }
diff --git a/tests/format-io-tests/area_density-tests/area_density-tests.cpp b/tests/format-io-tests/area_density-tests/area_density-tests.cpp
index 59d824d9..a385c06f 100644
--- a/tests/format-io-tests/area_density-tests/area_density-tests.cpp
+++ b/tests/format-io-tests/area_density-tests/area_density-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/area_density.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("area_density format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("area_density quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::area_density) == "1 [kg/m^2]");
 }
 TEST_CASE("area_density type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::area_density)>, mitama::quantity_t<std::decay_t<decltype(meter<-2>*kilograms)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::area_density)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-2>*kilograms)>>>);
 }
diff --git a/tests/format-io-tests/capacitance-tests/capacitance-tests.cpp b/tests/format-io-tests/capacitance-tests/capacitance-tests.cpp
index 78de6c28..a7283459 100644
--- a/tests/format-io-tests/capacitance-tests/capacitance-tests.cpp
+++ b/tests/format-io-tests/capacitance-tests/capacitance-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/capacitance.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("capacitance_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/catalytic_activity-tests/catalytic_activity-tests.cpp b/tests/format-io-tests/catalytic_activity-tests/catalytic_activity-tests.cpp
index d3d3e5b2..dba2136f 100644
--- a/tests/format-io-tests/catalytic_activity-tests/catalytic_activity-tests.cpp
+++ b/tests/format-io-tests/catalytic_activity-tests/catalytic_activity-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/catalytic_activity.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("catalytic_activity_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/catalytic_efficiency-tests/catalytic_efficiency-tests.cpp b/tests/format-io-tests/catalytic_efficiency-tests/catalytic_efficiency-tests.cpp
index f7bdcbd8..6f693656 100644
--- a/tests/format-io-tests/catalytic_efficiency-tests/catalytic_efficiency-tests.cpp
+++ b/tests/format-io-tests/catalytic_efficiency-tests/catalytic_efficiency-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/catalytic_efficiency.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("catalytic_efficiency format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("catalytic_efficiency quantifier format test", "[quantity][abbreviatio
   REQUIRE(fmt(1 | systems::si::catalytic_efficiency) == "1 [m^3/(mol s)]");
 }
 TEST_CASE("catalytic_efficiency type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::catalytic_efficiency)>, mitama::quantity_t<std::decay_t<decltype(meter<3>*second<-1>*mol<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::catalytic_efficiency)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<3>*second<-1>*mol<-1>)>>>);
 }
diff --git a/tests/format-io-tests/compressibility-tests/compressibility-tests.cpp b/tests/format-io-tests/compressibility-tests/compressibility-tests.cpp
index af71ff5a..95b32cf6 100644
--- a/tests/format-io-tests/compressibility-tests/compressibility-tests.cpp
+++ b/tests/format-io-tests/compressibility-tests/compressibility-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/compressibility.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("compressibility format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("compressibility quantifier format test", "[quantity][abbreviation]")
   REQUIRE(fmt(1 | systems::si::compressibility) == "1 [Pa^-1]");
 }
 TEST_CASE("compressibility type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::compressibility)>, mitama::quantity_t<std::decay_t<decltype(meters*kilogram<-1>*second<2>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::compressibility)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meters*kilogram<-1>*second<2>)>>>);
 }
diff --git a/tests/format-io-tests/conductance-tests/conductance-tests.cpp b/tests/format-io-tests/conductance-tests/conductance-tests.cpp
index 88b82ac2..c05d52d1 100644
--- a/tests/format-io-tests/conductance-tests/conductance-tests.cpp
+++ b/tests/format-io-tests/conductance-tests/conductance-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/conductance.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("conductance_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/crackle-tests/crackle-tests.cpp b/tests/format-io-tests/crackle-tests/crackle-tests.cpp
index 0a41f490..63e3ab96 100644
--- a/tests/format-io-tests/crackle-tests/crackle-tests.cpp
+++ b/tests/format-io-tests/crackle-tests/crackle-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/crackle.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("crackle format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("crackle quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::crackle) == "1 [m/s^5]");
 }
 TEST_CASE("crackle type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::crackle)>, mitama::quantity_t<std::decay_t<decltype(meters/second<5>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::crackle)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meters/second<5>)>>>);
 }
diff --git a/tests/format-io-tests/curvature-tests/curvature-tests.cpp b/tests/format-io-tests/curvature-tests/curvature-tests.cpp
index c90bc20b..62dc0574 100644
--- a/tests/format-io-tests/curvature-tests/curvature-tests.cpp
+++ b/tests/format-io-tests/curvature-tests/curvature-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/curvature.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("curvature format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("curvature quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::curvature) == "1 [m^-1]");
 }
 TEST_CASE("curvature type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::curvature)>, mitama::quantity_t<std::decay_t<decltype(meter<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::curvature)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-1>)>>>);
 }
diff --git a/tests/format-io-tests/density-tests/density-tests.cpp b/tests/format-io-tests/density-tests/density-tests.cpp
index cddfd628..0bd85583 100644
--- a/tests/format-io-tests/density-tests/density-tests.cpp
+++ b/tests/format-io-tests/density-tests/density-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/density.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("density format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("density quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::density) == "1 [kg/m^3]");
 }
 TEST_CASE("density type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::density)>, mitama::quantity_t<std::decay_t<decltype(meter<-3>*kilograms)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::density)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-3>*kilograms)>>>);
 }
diff --git a/tests/format-io-tests/derived-test-gen.sh b/tests/format-io-tests/derived-test-gen.sh
index 12cbc653..312ef8f2 100755
--- a/tests/format-io-tests/derived-test-gen.sh
+++ b/tests/format-io-tests/derived-test-gen.sh
@@ -6,6 +6,8 @@ cat <<EOS > $1-tests/$1-tests.cpp
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/$1.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("$1 format test", "[quantity][abbreviation]") {
@@ -15,7 +17,9 @@ TEST_CASE("$1 quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::$1) == "1 [$2]");
 }
 TEST_CASE("$1 type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::$1)>, mitama::quantity_t<std::decay_t<decltype($3)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<
+    std::decay_t<decltype(1|systems::si::$1)>,
+    mitama::systems::si::quantity_t<std::decay_t<decltype($3)>>>);
 }
 EOS
 cat <<EOS > $1-tests/CMakeLists.txt
diff --git a/tests/format-io-tests/diffusion_coefficient-tests/diffusion_coefficient-tests.cpp b/tests/format-io-tests/diffusion_coefficient-tests/diffusion_coefficient-tests.cpp
index 214cd242..1582ab11 100644
--- a/tests/format-io-tests/diffusion_coefficient-tests/diffusion_coefficient-tests.cpp
+++ b/tests/format-io-tests/diffusion_coefficient-tests/diffusion_coefficient-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/diffusion_coefficient.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("diffusion_coefficient format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("diffusion_coefficient quantifier format test", "[quantity][abbreviati
   REQUIRE(fmt(1 | systems::si::diffusion_coefficient) == "1 [m^2/s]");
 }
 TEST_CASE("diffusion_coefficient type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::diffusion_coefficient)>, mitama::quantity_t<std::decay_t<decltype(meter<2>*second<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::diffusion_coefficient)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<2>*second<-1>)>>>);
 }
diff --git a/tests/format-io-tests/dynamic_viscosity-tests/dynamic_viscosity-tests.cpp b/tests/format-io-tests/dynamic_viscosity-tests/dynamic_viscosity-tests.cpp
index 250531fa..dcfa5722 100644
--- a/tests/format-io-tests/dynamic_viscosity-tests/dynamic_viscosity-tests.cpp
+++ b/tests/format-io-tests/dynamic_viscosity-tests/dynamic_viscosity-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/dynamic_viscosity.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("dynamic_viscosity format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("dynamic_viscosity quantifier format test", "[quantity][abbreviation]"
   REQUIRE(fmt(1 | systems::si::dynamic_viscosity) == "1 [Pa s]");
 }
 TEST_CASE("dynamic_viscosity type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::dynamic_viscosity)>, mitama::quantity_t<std::decay_t<decltype(meter<-1>*kilograms*second<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::dynamic_viscosity)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-1>*kilograms*second<-1>)>>>);
 }
diff --git a/tests/format-io-tests/electoric_potential-tests/electoric_potential-tests.cpp b/tests/format-io-tests/electoric_potential-tests/electoric_potential-tests.cpp
index f44d9248..ebb76870 100644
--- a/tests/format-io-tests/electoric_potential-tests/electoric_potential-tests.cpp
+++ b/tests/format-io-tests/electoric_potential-tests/electoric_potential-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/electric_potential.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("electric_potential_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/electric_charge-tests/electric_charge-tests.cpp b/tests/format-io-tests/electric_charge-tests/electric_charge-tests.cpp
index 0016d023..55b0d98f 100644
--- a/tests/format-io-tests/electric_charge-tests/electric_charge-tests.cpp
+++ b/tests/format-io-tests/electric_charge-tests/electric_charge-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/electric_charge.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("electric_charge_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/electric_charge_density-tests/electric_charge_density-tests.cpp b/tests/format-io-tests/electric_charge_density-tests/electric_charge_density-tests.cpp
index 2d9d49ed..7a1d73a7 100644
--- a/tests/format-io-tests/electric_charge_density-tests/electric_charge_density-tests.cpp
+++ b/tests/format-io-tests/electric_charge_density-tests/electric_charge_density-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/electric_charge_density.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("electric_charge_density format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("electric_charge_density quantifier format test", "[quantity][abbrevia
   REQUIRE(fmt(1 | systems::si::electric_charge_density) == "1 [C/m^3]");
 }
 TEST_CASE("electric_charge_density type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::electric_charge_density)>, mitama::quantity_t<std::decay_t<decltype(meter<-3>*second<>*ampere<>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::electric_charge_density)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-3>*second<>*ampere<>)>>>);
 }
diff --git a/tests/format-io-tests/electric_current_density-tests/electric_current_density-tests.cpp b/tests/format-io-tests/electric_current_density-tests/electric_current_density-tests.cpp
index d32ce382..7dc5e2da 100644
--- a/tests/format-io-tests/electric_current_density-tests/electric_current_density-tests.cpp
+++ b/tests/format-io-tests/electric_current_density-tests/electric_current_density-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/electric_current_density.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("electric_current_density format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("electric_current_density quantifier format test", "[quantity][abbrevi
   REQUIRE(fmt(1 | systems::si::electric_current_density) == "1 [A/m^2]");
 }
 TEST_CASE("electric_current_density type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::electric_current_density)>, mitama::quantity_t<std::decay_t<decltype(meter<-2>*ampere<>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::electric_current_density)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-2>*ampere<>)>>>);
 }
diff --git a/tests/format-io-tests/electric_displacement_field-tests/electric_displacement_field-tests.cpp b/tests/format-io-tests/electric_displacement_field-tests/electric_displacement_field-tests.cpp
index 4f1e3572..99576bc9 100644
--- a/tests/format-io-tests/electric_displacement_field-tests/electric_displacement_field-tests.cpp
+++ b/tests/format-io-tests/electric_displacement_field-tests/electric_displacement_field-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/electric_displacement_field.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("electric_displacement_field format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("electric_displacement_field quantifier format test", "[quantity][abbr
   REQUIRE(fmt(1 | systems::si::electric_displacement_field) == "1 [C/m^2]");
 }
 TEST_CASE("electric_displacement_field type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::electric_displacement_field)>, mitama::quantity_t<std::decay_t<decltype(meter<-2>*seconds*ampere<>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::electric_displacement_field)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-2>*seconds*ampere<>)>>>);
 }
diff --git a/tests/format-io-tests/electric_field_strength-tests/electric_field_strength-tests.cpp b/tests/format-io-tests/electric_field_strength-tests/electric_field_strength-tests.cpp
index 169f72cf..65d38a5d 100644
--- a/tests/format-io-tests/electric_field_strength-tests/electric_field_strength-tests.cpp
+++ b/tests/format-io-tests/electric_field_strength-tests/electric_field_strength-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/electric_field_strength.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("electric_field_strength format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("electric_field_strength quantifier format test", "[quantity][abbrevia
   REQUIRE(fmt(1 | systems::si::electric_field_strength) == "1 [V/m]");
 }
 TEST_CASE("electric_field_strength type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::electric_field_strength)>, mitama::quantity_t<std::decay_t<decltype(meter<>*kilogram<>*second<-3>*ampere<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::electric_field_strength)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<>*kilogram<>*second<-3>*ampere<-1>)>>>);
 }
diff --git a/tests/format-io-tests/electric_potential-tests/electric_potential-tests.cpp b/tests/format-io-tests/electric_potential-tests/electric_potential-tests.cpp
index f44d9248..ebb76870 100644
--- a/tests/format-io-tests/electric_potential-tests/electric_potential-tests.cpp
+++ b/tests/format-io-tests/electric_potential-tests/electric_potential-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/electric_potential.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("electric_potential_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/electrical_conductivity-tests/electrical_conductivity-tests.cpp b/tests/format-io-tests/electrical_conductivity-tests/electrical_conductivity-tests.cpp
index 53b506cc..4328509e 100644
--- a/tests/format-io-tests/electrical_conductivity-tests/electrical_conductivity-tests.cpp
+++ b/tests/format-io-tests/electrical_conductivity-tests/electrical_conductivity-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/electrical_conductivity.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("electrical_conductivity format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("electrical_conductivity quantifier format test", "[quantity][abbrevia
   REQUIRE(fmt(1 | systems::si::electrical_conductivity) == "1 [S/m]");
 }
 TEST_CASE("electrical_conductivity type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::electrical_conductivity)>, mitama::quantity_t<std::decay_t<decltype(meter<-3>*kilogram<-1>*second<3>*ampere<2>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::electrical_conductivity)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-3>*kilogram<-1>*second<3>*ampere<2>)>>>);
 }
diff --git a/tests/format-io-tests/electron_mobility-tests/electron_mobility-tests.cpp b/tests/format-io-tests/electron_mobility-tests/electron_mobility-tests.cpp
index 9c789e13..a2535f12 100644
--- a/tests/format-io-tests/electron_mobility-tests/electron_mobility-tests.cpp
+++ b/tests/format-io-tests/electron_mobility-tests/electron_mobility-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/electron_mobility.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("electron_mobility format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("electron_mobility quantifier format test", "[quantity][abbreviation]"
   REQUIRE(fmt(1 | systems::si::electron_mobility) == "1 [m^2/(V s)]");
 }
 TEST_CASE("electron_mobility type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::electron_mobility)>, mitama::quantity_t<std::decay_t<decltype(kilogram<-1>*second<2>*ampere<1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::electron_mobility)>, mitama::systems::si::quantity_t<std::decay_t<decltype(kilogram<-1>*second<2>*ampere<1>)>>>);
 }
diff --git a/tests/format-io-tests/energy-tests/energy-tests.cpp b/tests/format-io-tests/energy-tests/energy-tests.cpp
index 3450392c..0b59b73f 100644
--- a/tests/format-io-tests/energy-tests/energy-tests.cpp
+++ b/tests/format-io-tests/energy-tests/energy-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/energy.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("energy_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/energy_density-tests/energy_density-tests.cpp b/tests/format-io-tests/energy_density-tests/energy_density-tests.cpp
index 195481e5..03875528 100644
--- a/tests/format-io-tests/energy_density-tests/energy_density-tests.cpp
+++ b/tests/format-io-tests/energy_density-tests/energy_density-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/energy_density.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("energy_density format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("energy_density quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::energy_density) == "1 [J/m^3]");
 }
 TEST_CASE("energy_density type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::energy_density)>, mitama::quantity_t<std::decay_t<decltype(meter<-1>*kilograms*second<-2>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::energy_density)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-1>*kilograms*second<-2>)>>>);
 }
diff --git a/tests/format-io-tests/energy_flux_density-tests/energy_flux_density-tests.cpp b/tests/format-io-tests/energy_flux_density-tests/energy_flux_density-tests.cpp
index 7deb1cef..18e38350 100644
--- a/tests/format-io-tests/energy_flux_density-tests/energy_flux_density-tests.cpp
+++ b/tests/format-io-tests/energy_flux_density-tests/energy_flux_density-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/energy_flux_density.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("energy_flux_density format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("energy_flux_density quantifier format test", "[quantity][abbreviation
   REQUIRE(fmt(1 | systems::si::energy_flux_density) == "1 [J/(m^2 s)]");
 }
 TEST_CASE("energy_flux_density type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::energy_flux_density)>, mitama::quantity_t<std::decay_t<decltype(kilograms*second<-3>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::energy_flux_density)>, mitama::systems::si::quantity_t<std::decay_t<decltype(kilograms*second<-3>)>>>);
 }
diff --git a/tests/format-io-tests/entropy-tests/entropy-tests.cpp b/tests/format-io-tests/entropy-tests/entropy-tests.cpp
index 274cdb9a..df697ebf 100644
--- a/tests/format-io-tests/entropy-tests/entropy-tests.cpp
+++ b/tests/format-io-tests/entropy-tests/entropy-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/entropy.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("entropy format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("entropy quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::entropy) == "1 [J/K]");
 }
 TEST_CASE("entropy type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::entropy)>, mitama::quantity_t<std::decay_t<decltype(meter<2>*kilograms*second<-2>*kelvin<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::entropy)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<2>*kilograms*second<-2>*kelvin<-1>)>>>);
 }
diff --git a/tests/format-io-tests/equivalent_dose-tests/equivalent_dose-tests.cpp b/tests/format-io-tests/equivalent_dose-tests/equivalent_dose-tests.cpp
index 2888299f..2f989e51 100644
--- a/tests/format-io-tests/equivalent_dose-tests/equivalent_dose-tests.cpp
+++ b/tests/format-io-tests/equivalent_dose-tests/equivalent_dose-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/equivalent_dose.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("equivalent_dose_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/exposure-tests/exposure-tests.cpp b/tests/format-io-tests/exposure-tests/exposure-tests.cpp
index 647ab978..ea8c009f 100644
--- a/tests/format-io-tests/exposure-tests/exposure-tests.cpp
+++ b/tests/format-io-tests/exposure-tests/exposure-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/exposure.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("exposure format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("exposure quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::exposure) == "1 [C/kg]");
 }
 TEST_CASE("exposure type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::exposure)>, mitama::quantity_t<std::decay_t<decltype(kilogram<-1>*second<>*ampere<>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::exposure)>, mitama::systems::si::quantity_t<std::decay_t<decltype(kilogram<-1>*second<>*ampere<>)>>>);
 }
diff --git a/tests/format-io-tests/force-tests/force-tests.cpp b/tests/format-io-tests/force-tests/force-tests.cpp
index 99ce5bc9..4a240aa3 100644
--- a/tests/format-io-tests/force-tests/force-tests.cpp
+++ b/tests/format-io-tests/force-tests/force-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/force.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("force_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/frequency-tests/frequency-tests.cpp b/tests/format-io-tests/frequency-tests/frequency-tests.cpp
index d3610504..2a946771 100644
--- a/tests/format-io-tests/frequency-tests/frequency-tests.cpp
+++ b/tests/format-io-tests/frequency-tests/frequency-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/frequency.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("frequency_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/frequency_drift-tests/frequency_drift-tests.cpp b/tests/format-io-tests/frequency_drift-tests/frequency_drift-tests.cpp
index d8384947..e84719d0 100644
--- a/tests/format-io-tests/frequency_drift-tests/frequency_drift-tests.cpp
+++ b/tests/format-io-tests/frequency_drift-tests/frequency_drift-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/frequency_drift.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("frequency_drift format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("frequency_drift quantifier format test", "[quantity][abbreviation]")
   REQUIRE(fmt(1 | systems::si::frequency_drift) == "1 [Hz/s]");
 }
 TEST_CASE("frequency_drift type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::frequency_drift)>, mitama::quantity_t<std::decay_t<decltype(second<-2>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::frequency_drift)>, mitama::systems::si::quantity_t<std::decay_t<decltype(second<-2>)>>>);
 }
diff --git a/tests/format-io-tests/fuel_efficiency-tests/fuel_efficiency-tests.cpp b/tests/format-io-tests/fuel_efficiency-tests/fuel_efficiency-tests.cpp
index a0a1a764..081c04c1 100644
--- a/tests/format-io-tests/fuel_efficiency-tests/fuel_efficiency-tests.cpp
+++ b/tests/format-io-tests/fuel_efficiency-tests/fuel_efficiency-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/fuel_efficiency.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("fuel_efficiency format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("fuel_efficiency quantifier format test", "[quantity][abbreviation]")
   REQUIRE(fmt(1 | systems::si::fuel_efficiency) == "1 [m/m^3]");
 }
 TEST_CASE("fuel_efficiency type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::fuel_efficiency)>, mitama::quantity_t<std::decay_t<decltype(meter<-2>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::fuel_efficiency)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-2>)>>>);
 }
diff --git a/tests/format-io-tests/heat-tests/heat-tests.cpp b/tests/format-io-tests/heat-tests/heat-tests.cpp
index 1f9ece2e..4fa0e760 100644
--- a/tests/format-io-tests/heat-tests/heat-tests.cpp
+++ b/tests/format-io-tests/heat-tests/heat-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/heat.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("heat_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/heat_capacity-tests/heat_capacity-tests.cpp b/tests/format-io-tests/heat_capacity-tests/heat_capacity-tests.cpp
index 9a5d1afb..aa5b664e 100644
--- a/tests/format-io-tests/heat_capacity-tests/heat_capacity-tests.cpp
+++ b/tests/format-io-tests/heat_capacity-tests/heat_capacity-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/heat_capacity.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("heat_capacity format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("heat_capacity quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::heat_capacity) == "1 [J/K]");
 }
 TEST_CASE("heat_capacity type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::heat_capacity)>, mitama::quantity_t<std::decay_t<decltype(meter<2>*kilograms*second<-2>*kelvin<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::heat_capacity)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<2>*kilograms*second<-2>*kelvin<-1>)>>>);
 }
diff --git a/tests/format-io-tests/heat_flux_density-tests/heat_flux_density-tests.cpp b/tests/format-io-tests/heat_flux_density-tests/heat_flux_density-tests.cpp
index ae2d575d..8d647470 100644
--- a/tests/format-io-tests/heat_flux_density-tests/heat_flux_density-tests.cpp
+++ b/tests/format-io-tests/heat_flux_density-tests/heat_flux_density-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/heat_flux_density.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("heat_flux_density format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("heat_flux_density quantifier format test", "[quantity][abbreviation]"
   REQUIRE(fmt(1 | systems::si::heat_flux_density) == "1 [W/m^2]");
 }
 TEST_CASE("heat_flux_density type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::heat_flux_density)>, mitama::quantity_t<std::decay_t<decltype(kilograms*second<-3>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::heat_flux_density)>, mitama::systems::si::quantity_t<std::decay_t<decltype(kilograms*second<-3>)>>>);
 }
diff --git a/tests/format-io-tests/illuminance-tests/illuminance-tests.cpp b/tests/format-io-tests/illuminance-tests/illuminance-tests.cpp
index 6d0a4fbe..fdbc541a 100644
--- a/tests/format-io-tests/illuminance-tests/illuminance-tests.cpp
+++ b/tests/format-io-tests/illuminance-tests/illuminance-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/illuminance.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("illuminance_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/impedance-tests/impedance-tests.cpp b/tests/format-io-tests/impedance-tests/impedance-tests.cpp
index 15013eaf..14fefee7 100644
--- a/tests/format-io-tests/impedance-tests/impedance-tests.cpp
+++ b/tests/format-io-tests/impedance-tests/impedance-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/impedance.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("impedance_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/impulse-tests/impulse-tests.cpp b/tests/format-io-tests/impulse-tests/impulse-tests.cpp
index ae3f00b5..ea3fd3c1 100644
--- a/tests/format-io-tests/impulse-tests/impulse-tests.cpp
+++ b/tests/format-io-tests/impulse-tests/impulse-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/impulse.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("impulse format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("impulse quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::impulse) == "1 [N s]");
 }
 TEST_CASE("impulse type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::impulse)>, mitama::quantity_t<std::decay_t<decltype(meters*kilograms*second<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::impulse)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meters*kilograms*second<-1>)>>>);
 }
diff --git a/tests/format-io-tests/inductance-tests/inductance-tests.cpp b/tests/format-io-tests/inductance-tests/inductance-tests.cpp
index 784de5a6..ffe288bc 100644
--- a/tests/format-io-tests/inductance-tests/inductance-tests.cpp
+++ b/tests/format-io-tests/inductance-tests/inductance-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/inductance.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("inductance_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/irradiance-tests/irradiance-tests.cpp b/tests/format-io-tests/irradiance-tests/irradiance-tests.cpp
index dd386c42..69caa5df 100644
--- a/tests/format-io-tests/irradiance-tests/irradiance-tests.cpp
+++ b/tests/format-io-tests/irradiance-tests/irradiance-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/irradiance.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("irradiance format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("irradiance quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::irradiance) == "1 [W/m^2]");
 }
 TEST_CASE("irradiance type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::irradiance)>, mitama::quantity_t<std::decay_t<decltype(kilograms*second<-3>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::irradiance)>, mitama::systems::si::quantity_t<std::decay_t<decltype(kilograms*second<-3>)>>>);
 }
diff --git a/tests/format-io-tests/jerk-tests/jerk-tests.cpp b/tests/format-io-tests/jerk-tests/jerk-tests.cpp
index d83c9101..f44be7e7 100644
--- a/tests/format-io-tests/jerk-tests/jerk-tests.cpp
+++ b/tests/format-io-tests/jerk-tests/jerk-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/jerk.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("jerk format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("jerk quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::jerk) == "1 [m/s^3]");
 }
 TEST_CASE("jerk type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::jerk)>, mitama::quantity_t<std::decay_t<decltype(meters/second<3>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::jerk)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meters/second<3>)>>>);
 }
diff --git a/tests/format-io-tests/kinematic_viscosity-tests/kinematic_viscosity-tests.cpp b/tests/format-io-tests/kinematic_viscosity-tests/kinematic_viscosity-tests.cpp
index cfb4aefa..9e6af28b 100644
--- a/tests/format-io-tests/kinematic_viscosity-tests/kinematic_viscosity-tests.cpp
+++ b/tests/format-io-tests/kinematic_viscosity-tests/kinematic_viscosity-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/kinematic_viscosity.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("kinematic_viscosity format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("kinematic_viscosity quantifier format test", "[quantity][abbreviation
   REQUIRE(fmt(1 | systems::si::kinematic_viscosity) == "1 [m^2/s]");
 }
 TEST_CASE("kinematic_viscosity type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::kinematic_viscosity)>, mitama::quantity_t<std::decay_t<decltype(meter<2>*second<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::kinematic_viscosity)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<2>*second<-1>)>>>);
 }
diff --git a/tests/format-io-tests/linear_charge_density-tests/linear_charge_density-tests.cpp b/tests/format-io-tests/linear_charge_density-tests/linear_charge_density-tests.cpp
index 866d9952..6382988a 100644
--- a/tests/format-io-tests/linear_charge_density-tests/linear_charge_density-tests.cpp
+++ b/tests/format-io-tests/linear_charge_density-tests/linear_charge_density-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/linear_charge_density.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("linear_charge_density format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("linear_charge_density quantifier format test", "[quantity][abbreviati
   REQUIRE(fmt(1 | systems::si::linear_charge_density) == "1 [C/m]");
 }
 TEST_CASE("linear_charge_density type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::linear_charge_density)>, mitama::quantity_t<std::decay_t<decltype(meter<-1>*second<>*ampere<>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::linear_charge_density)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-1>*second<>*ampere<>)>>>);
 }
diff --git a/tests/format-io-tests/linear_mass_density-tests/linear_mass_density-tests.cpp b/tests/format-io-tests/linear_mass_density-tests/linear_mass_density-tests.cpp
index 88fe9cd2..79944ae7 100644
--- a/tests/format-io-tests/linear_mass_density-tests/linear_mass_density-tests.cpp
+++ b/tests/format-io-tests/linear_mass_density-tests/linear_mass_density-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/linear_mass_density.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("linear_mass_density format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("linear_mass_density quantifier format test", "[quantity][abbreviation
   REQUIRE(fmt(1 | systems::si::linear_mass_density) == "1 [kg/m]");
 }
 TEST_CASE("linear_mass_density type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::linear_mass_density)>, mitama::quantity_t<std::decay_t<decltype(meter<-1>*kilograms)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::linear_mass_density)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-1>*kilograms)>>>);
 }
diff --git a/tests/format-io-tests/luminance-tests/luminance-tests.cpp b/tests/format-io-tests/luminance-tests/luminance-tests.cpp
index b6f80e13..bab4d4fc 100644
--- a/tests/format-io-tests/luminance-tests/luminance-tests.cpp
+++ b/tests/format-io-tests/luminance-tests/luminance-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/luminance.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("luminance format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("luminance quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::luminance) == "1 [cd/m^2]");
 }
 TEST_CASE("luminance type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::luminance)>, mitama::quantity_t<std::decay_t<decltype(meter<-2>*candelas)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::luminance)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-2>*candelas)>>>);
 }
diff --git a/tests/format-io-tests/luminous_efficacy-tests/luminous_efficacy-tests.cpp b/tests/format-io-tests/luminous_efficacy-tests/luminous_efficacy-tests.cpp
index e8c7f38f..5901f170 100644
--- a/tests/format-io-tests/luminous_efficacy-tests/luminous_efficacy-tests.cpp
+++ b/tests/format-io-tests/luminous_efficacy-tests/luminous_efficacy-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/luminous_efficacy.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("luminous_efficacy format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("luminous_efficacy quantifier format test", "[quantity][abbreviation]"
   REQUIRE(fmt(1 | systems::si::luminous_efficacy) == "1 [lm/W]");
 }
 TEST_CASE("luminous_efficacy type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::luminous_efficacy)>, mitama::quantity_t<std::decay_t<decltype(meter<-2>*kilogram<-1>*second<3>*candelas*steradian)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::luminous_efficacy)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-2>*kilogram<-1>*second<3>*candelas*steradian)>>>);
 }
diff --git a/tests/format-io-tests/luminous_energy-tests/luminous_energy-tests.cpp b/tests/format-io-tests/luminous_energy-tests/luminous_energy-tests.cpp
index 371d4dfe..3810b459 100644
--- a/tests/format-io-tests/luminous_energy-tests/luminous_energy-tests.cpp
+++ b/tests/format-io-tests/luminous_energy-tests/luminous_energy-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/luminous_energy.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("luminous_energy format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("luminous_energy quantifier format test", "[quantity][abbreviation]")
   REQUIRE(fmt(1 | systems::si::luminous_energy) == "1 [lm s]");
 }
 TEST_CASE("luminous_energy type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::luminous_energy)>, mitama::quantity_t<std::decay_t<decltype(seconds*candelas*steradian)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::luminous_energy)>, mitama::systems::si::quantity_t<std::decay_t<decltype(seconds*candelas*steradian)>>>);
 }
diff --git a/tests/format-io-tests/luminous_exposure-tests/luminous_exposure-tests.cpp b/tests/format-io-tests/luminous_exposure-tests/luminous_exposure-tests.cpp
index 25bd9bdd..034f5063 100644
--- a/tests/format-io-tests/luminous_exposure-tests/luminous_exposure-tests.cpp
+++ b/tests/format-io-tests/luminous_exposure-tests/luminous_exposure-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/luminous_exposure.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("luminous_exposure format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("luminous_exposure quantifier format test", "[quantity][abbreviation]"
   REQUIRE(fmt(1 | systems::si::luminous_exposure) == "1 [lx s]");
 }
 TEST_CASE("luminous_exposure type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::luminous_exposure)>, mitama::quantity_t<std::decay_t<decltype(meter<-2>*seconds*candelas*steradian)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::luminous_exposure)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-2>*seconds*candelas*steradian)>>>);
 }
diff --git a/tests/format-io-tests/luminous_flux-tests/luminous_flux-tests.cpp b/tests/format-io-tests/luminous_flux-tests/luminous_flux-tests.cpp
index 19c004ff..6d2db546 100644
--- a/tests/format-io-tests/luminous_flux-tests/luminous_flux-tests.cpp
+++ b/tests/format-io-tests/luminous_flux-tests/luminous_flux-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/luminous_flux.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("luminous_flux_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/magnetic_dipole_moment-tests/magnetic_dipole_moment-tests.cpp b/tests/format-io-tests/magnetic_dipole_moment-tests/magnetic_dipole_moment-tests.cpp
index ec20f6d1..598945a2 100644
--- a/tests/format-io-tests/magnetic_dipole_moment-tests/magnetic_dipole_moment-tests.cpp
+++ b/tests/format-io-tests/magnetic_dipole_moment-tests/magnetic_dipole_moment-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/magnetic_dipole_moment.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("magnetic_dipole_moment format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("magnetic_dipole_moment quantifier format test", "[quantity][abbreviat
   REQUIRE(fmt(1 | systems::si::magnetic_dipole_moment) == "1 [J/T]");
 }
 TEST_CASE("magnetic_dipole_moment type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::magnetic_dipole_moment)>, mitama::quantity_t<std::decay_t<decltype(meter<2>*ampere<>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::magnetic_dipole_moment)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<2>*ampere<>)>>>);
 }
diff --git a/tests/format-io-tests/magnetic_field_strength-tests/magnetic_field_strength-tests.cpp b/tests/format-io-tests/magnetic_field_strength-tests/magnetic_field_strength-tests.cpp
index 9607847f..08599eea 100644
--- a/tests/format-io-tests/magnetic_field_strength-tests/magnetic_field_strength-tests.cpp
+++ b/tests/format-io-tests/magnetic_field_strength-tests/magnetic_field_strength-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/magnetic_field_strength.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("magnetic_field_strength format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("magnetic_field_strength quantifier format test", "[quantity][abbrevia
   REQUIRE(fmt(1 | systems::si::magnetic_field_strength) == "1 [A/m]");
 }
 TEST_CASE("magnetic_field_strength type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::magnetic_field_strength)>, mitama::quantity_t<std::decay_t<decltype(meter<-1>*ampere<>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::magnetic_field_strength)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-1>*ampere<>)>>>);
 }
diff --git a/tests/format-io-tests/magnetic_flux-tests/magnetic_flux-tests.cpp b/tests/format-io-tests/magnetic_flux-tests/magnetic_flux-tests.cpp
index 5c3c71de..5ca0c766 100644
--- a/tests/format-io-tests/magnetic_flux-tests/magnetic_flux-tests.cpp
+++ b/tests/format-io-tests/magnetic_flux-tests/magnetic_flux-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/magnetic_flux.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("magnetic_flux_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/magnetic_flux_density-tests/magnetic_flux_density-tests.cpp b/tests/format-io-tests/magnetic_flux_density-tests/magnetic_flux_density-tests.cpp
index 4173f2c6..d7e83dc5 100644
--- a/tests/format-io-tests/magnetic_flux_density-tests/magnetic_flux_density-tests.cpp
+++ b/tests/format-io-tests/magnetic_flux_density-tests/magnetic_flux_density-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/magnetic_flux_density.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("magnetic_flux_density_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/magnetic_moment-tests/magnetic_moment-tests.cpp b/tests/format-io-tests/magnetic_moment-tests/magnetic_moment-tests.cpp
index c45ae995..c2b92ad2 100644
--- a/tests/format-io-tests/magnetic_moment-tests/magnetic_moment-tests.cpp
+++ b/tests/format-io-tests/magnetic_moment-tests/magnetic_moment-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/magnetic_moment.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("magnetic_moment format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("magnetic_moment quantifier format test", "[quantity][abbreviation]")
   REQUIRE(fmt(1 | systems::si::magnetic_moment) == "1 [Wb m]");
 }
 TEST_CASE("magnetic_moment type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::magnetic_moment)>, mitama::quantity_t<std::decay_t<decltype(meter<3>*kilogram<>*second<-2>*ampere<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::magnetic_moment)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<3>*kilogram<>*second<-2>*ampere<-1>)>>>);
 }
diff --git a/tests/format-io-tests/magnetic_reluctance-tests/magnetic_reluctance-tests.cpp b/tests/format-io-tests/magnetic_reluctance-tests/magnetic_reluctance-tests.cpp
index fe97d494..ba0b4610 100644
--- a/tests/format-io-tests/magnetic_reluctance-tests/magnetic_reluctance-tests.cpp
+++ b/tests/format-io-tests/magnetic_reluctance-tests/magnetic_reluctance-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/magnetic_reluctance.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("magnetic_reluctance format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("magnetic_reluctance quantifier format test", "[quantity][abbreviation
   REQUIRE(fmt(1 | systems::si::magnetic_reluctance) == "1 [H^-1]");
 }
 TEST_CASE("magnetic_reluctance type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::magnetic_reluctance)>, mitama::quantity_t<std::decay_t<decltype(meter<-2>*kilogram<-1>*second<2>*ampere<2>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::magnetic_reluctance)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-2>*kilogram<-1>*second<2>*ampere<2>)>>>);
 }
diff --git a/tests/format-io-tests/magnetic_rigidity-tests/magnetic_rigidity-tests.cpp b/tests/format-io-tests/magnetic_rigidity-tests/magnetic_rigidity-tests.cpp
index 2d21508e..c65d78f0 100644
--- a/tests/format-io-tests/magnetic_rigidity-tests/magnetic_rigidity-tests.cpp
+++ b/tests/format-io-tests/magnetic_rigidity-tests/magnetic_rigidity-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/magnetic_rigidity.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("magnetic_rigidity format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("magnetic_rigidity quantifier format test", "[quantity][abbreviation]"
   REQUIRE(fmt(1 | systems::si::magnetic_rigidity) == "1 [T m]");
 }
 TEST_CASE("magnetic_rigidity type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::magnetic_rigidity)>, mitama::quantity_t<std::decay_t<decltype(meter<>*kilogram<>*second<-2>*ampere<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::magnetic_rigidity)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<>*kilogram<>*second<-2>*ampere<-1>)>>>);
 }
diff --git a/tests/format-io-tests/magnetic_susceptibility-tests/magnetic_susceptibility-tests.cpp b/tests/format-io-tests/magnetic_susceptibility-tests/magnetic_susceptibility-tests.cpp
index d88e1a61..fc355cfa 100644
--- a/tests/format-io-tests/magnetic_susceptibility-tests/magnetic_susceptibility-tests.cpp
+++ b/tests/format-io-tests/magnetic_susceptibility-tests/magnetic_susceptibility-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/magnetic_susceptibility.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("magnetic_susceptibility format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("magnetic_susceptibility quantifier format test", "[quantity][abbrevia
   REQUIRE(fmt(1 | systems::si::magnetic_susceptibility) == "1 [m/H]");
 }
 TEST_CASE("magnetic_susceptibility type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::magnetic_susceptibility)>, mitama::quantity_t<std::decay_t<decltype(meter<-1>*kilogram<-1>*second<2>*ampere<2>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::magnetic_susceptibility)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-1>*kilogram<-1>*second<2>*ampere<2>)>>>);
 }
diff --git a/tests/format-io-tests/magnetic_vector_potential-tests/magnetic_vector_potential-tests.cpp b/tests/format-io-tests/magnetic_vector_potential-tests/magnetic_vector_potential-tests.cpp
index a540747d..5870fcb3 100644
--- a/tests/format-io-tests/magnetic_vector_potential-tests/magnetic_vector_potential-tests.cpp
+++ b/tests/format-io-tests/magnetic_vector_potential-tests/magnetic_vector_potential-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/magnetic_vector_potential.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("magnetic_vector_potential format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("magnetic_vector_potential quantifier format test", "[quantity][abbrev
   REQUIRE(fmt(1 | systems::si::magnetic_vector_potential) == "1 [Wb/m]");
 }
 TEST_CASE("magnetic_vector_potential type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::magnetic_vector_potential)>, mitama::quantity_t<std::decay_t<decltype(meter<>*kilogram<>*second<-2>*ampere<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::magnetic_vector_potential)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<>*kilogram<>*second<-2>*ampere<-1>)>>>);
 }
diff --git a/tests/format-io-tests/magnetization-tests/magnetization-tests.cpp b/tests/format-io-tests/magnetization-tests/magnetization-tests.cpp
index a958f7b0..8c748a95 100644
--- a/tests/format-io-tests/magnetization-tests/magnetization-tests.cpp
+++ b/tests/format-io-tests/magnetization-tests/magnetization-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/magnetization.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("magnetization format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("magnetization quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::magnetization) == "1 [A/m]");
 }
 TEST_CASE("magnetization type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::magnetization)>, mitama::quantity_t<std::decay_t<decltype(meter<-1>*ampere<>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::magnetization)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-1>*ampere<>)>>>);
 }
diff --git a/tests/format-io-tests/magnetomotive_force-tests/magnetomotive_force-tests.cpp b/tests/format-io-tests/magnetomotive_force-tests/magnetomotive_force-tests.cpp
index 16ed44dd..3c0a749e 100644
--- a/tests/format-io-tests/magnetomotive_force-tests/magnetomotive_force-tests.cpp
+++ b/tests/format-io-tests/magnetomotive_force-tests/magnetomotive_force-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/magnetomotive_force.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("magnetomotive_force format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("magnetomotive_force quantifier format test", "[quantity][abbreviation
   REQUIRE(fmt(1 | systems::si::magnetomotive_force) == "1 [A rad]");
 }
 TEST_CASE("magnetomotive_force type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::magnetomotive_force)>, mitama::quantity_t<std::decay_t<decltype(ampere<>*radian)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::magnetomotive_force)>, mitama::systems::si::quantity_t<std::decay_t<decltype(ampere<>*radian)>>>);
 }
diff --git a/tests/format-io-tests/mass_flow_rate-tests/mass_flow_rate-tests.cpp b/tests/format-io-tests/mass_flow_rate-tests/mass_flow_rate-tests.cpp
index ad5769ad..1b5aec68 100644
--- a/tests/format-io-tests/mass_flow_rate-tests/mass_flow_rate-tests.cpp
+++ b/tests/format-io-tests/mass_flow_rate-tests/mass_flow_rate-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/mass_flow_rate.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("mass_flow_rate format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("mass_flow_rate quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::mass_flow_rate) == "1 [kg/s]");
 }
 TEST_CASE("mass_flow_rate type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::mass_flow_rate)>, mitama::quantity_t<std::decay_t<decltype(kilograms/seconds)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::mass_flow_rate)>, mitama::systems::si::quantity_t<std::decay_t<decltype(kilograms/seconds)>>>);
 }
diff --git a/tests/format-io-tests/molality-tests/molality-tests.cpp b/tests/format-io-tests/molality-tests/molality-tests.cpp
index 47fe3df4..08c80451 100644
--- a/tests/format-io-tests/molality-tests/molality-tests.cpp
+++ b/tests/format-io-tests/molality-tests/molality-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/molality.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("molality format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("molality quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::molality) == "1 [mol/kg]");
 }
 TEST_CASE("molality type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::molality)>, mitama::quantity_t<std::decay_t<decltype(kilogram<-1>*mol<>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::molality)>, mitama::systems::si::quantity_t<std::decay_t<decltype(kilogram<-1>*mol<>)>>>);
 }
diff --git a/tests/format-io-tests/molar_conductivity-tests/molar_conductivity-tests.cpp b/tests/format-io-tests/molar_conductivity-tests/molar_conductivity-tests.cpp
index d21ba3b0..e045c348 100644
--- a/tests/format-io-tests/molar_conductivity-tests/molar_conductivity-tests.cpp
+++ b/tests/format-io-tests/molar_conductivity-tests/molar_conductivity-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/molar_conductivity.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("molar_conductivity format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("molar_conductivity quantifier format test", "[quantity][abbreviation]
   REQUIRE(fmt(1 | systems::si::molar_conductivity) == "1 [S m^2/mol]");
 }
 TEST_CASE("molar_conductivity type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::molar_conductivity)>, mitama::quantity_t<std::decay_t<decltype(kilogram<-1>*second<3>*ampere<2>*mol<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::molar_conductivity)>, mitama::systems::si::quantity_t<std::decay_t<decltype(kilogram<-1>*second<3>*ampere<2>*mol<-1>)>>>);
 }
diff --git a/tests/format-io-tests/molar_energy-tests/molar_energy-tests.cpp b/tests/format-io-tests/molar_energy-tests/molar_energy-tests.cpp
index c375a374..d2afba88 100644
--- a/tests/format-io-tests/molar_energy-tests/molar_energy-tests.cpp
+++ b/tests/format-io-tests/molar_energy-tests/molar_energy-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/molar_energy.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("molar_energy format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("molar_energy quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::molar_energy) == "1 [J/mol]");
 }
 TEST_CASE("molar_energy type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::molar_energy)>, mitama::quantity_t<std::decay_t<decltype(meter<2>*kilograms*second<-2>*mol<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::molar_energy)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<2>*kilograms*second<-2>*mol<-1>)>>>);
 }
diff --git a/tests/format-io-tests/molar_entropy-tests/molar_entropy-tests.cpp b/tests/format-io-tests/molar_entropy-tests/molar_entropy-tests.cpp
index 1587e2b3..cbf1832a 100644
--- a/tests/format-io-tests/molar_entropy-tests/molar_entropy-tests.cpp
+++ b/tests/format-io-tests/molar_entropy-tests/molar_entropy-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/molar_entropy.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("molar_entropy format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("molar_entropy quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::molar_entropy) == "1 [J/(K mol)]");
 }
 TEST_CASE("molar_entropy type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::molar_entropy)>, mitama::quantity_t<std::decay_t<decltype(meter<2>*kilograms*second<-2>*kelvin<-1>*mol<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::molar_entropy)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<2>*kilograms*second<-2>*kelvin<-1>*mol<-1>)>>>);
 }
diff --git a/tests/format-io-tests/molar_heat_capacity-tests/molar_heat_capacity-tests.cpp b/tests/format-io-tests/molar_heat_capacity-tests/molar_heat_capacity-tests.cpp
index 885f4d42..baa31fa9 100644
--- a/tests/format-io-tests/molar_heat_capacity-tests/molar_heat_capacity-tests.cpp
+++ b/tests/format-io-tests/molar_heat_capacity-tests/molar_heat_capacity-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/molar_heat_capacity.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("molar_heat_capacity format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("molar_heat_capacity quantifier format test", "[quantity][abbreviation
   REQUIRE(fmt(1 | systems::si::molar_heat_capacity) == "1 [J/(K mol)]");
 }
 TEST_CASE("molar_heat_capacity type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::molar_heat_capacity)>, mitama::quantity_t<std::decay_t<decltype(meter<2>*kilograms*second<-2>*kelvin<-1>*mol<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::molar_heat_capacity)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<2>*kilograms*second<-2>*kelvin<-1>*mol<-1>)>>>);
 }
diff --git a/tests/format-io-tests/molar_mass-tests/molar_mass-tests.cpp b/tests/format-io-tests/molar_mass-tests/molar_mass-tests.cpp
index 92ee0c24..0dd199d1 100644
--- a/tests/format-io-tests/molar_mass-tests/molar_mass-tests.cpp
+++ b/tests/format-io-tests/molar_mass-tests/molar_mass-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/molar_mass.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("molar_mass format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("molar_mass quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::molar_mass) == "1 [kg/mol]");
 }
 TEST_CASE("molar_mass type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::molar_mass)>, mitama::quantity_t<std::decay_t<decltype(kilogram<>/mol<>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::molar_mass)>, mitama::systems::si::quantity_t<std::decay_t<decltype(kilogram<>/mol<>)>>>);
 }
diff --git a/tests/format-io-tests/molar_volume-tests/molar_volume-tests.cpp b/tests/format-io-tests/molar_volume-tests/molar_volume-tests.cpp
index 734807cd..e14f9a2c 100644
--- a/tests/format-io-tests/molar_volume-tests/molar_volume-tests.cpp
+++ b/tests/format-io-tests/molar_volume-tests/molar_volume-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/molar_volume.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("molar_volume format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("molar_volume quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::molar_volume) == "1 [m^3/mol]");
 }
 TEST_CASE("molar_volume type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::molar_volume)>, mitama::quantity_t<std::decay_t<decltype(meter<3>*mol<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::molar_volume)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<3>*mol<-1>)>>>);
 }
diff --git a/tests/format-io-tests/molarity-tests/molarity-tests.cpp b/tests/format-io-tests/molarity-tests/molarity-tests.cpp
index 76a06107..6fdad6c9 100644
--- a/tests/format-io-tests/molarity-tests/molarity-tests.cpp
+++ b/tests/format-io-tests/molarity-tests/molarity-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/molarity.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("molarity format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("molarity quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::molarity) == "1 [mol/m^3]");
 }
 TEST_CASE("molarity type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::molarity)>, mitama::quantity_t<std::decay_t<decltype(meter<-3>*mol<>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::molarity)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-3>*mol<>)>>>);
 }
diff --git a/tests/format-io-tests/moment_of_inertia-tests/moment_of_inertia-tests.cpp b/tests/format-io-tests/moment_of_inertia-tests/moment_of_inertia-tests.cpp
index 5964f997..5ad934ed 100644
--- a/tests/format-io-tests/moment_of_inertia-tests/moment_of_inertia-tests.cpp
+++ b/tests/format-io-tests/moment_of_inertia-tests/moment_of_inertia-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/moment_of_inertia.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("moment_of_inertia format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("moment_of_inertia quantifier format test", "[quantity][abbreviation]"
   REQUIRE(fmt(1 | systems::si::moment_of_inertia) == "1 [kg m^2]");
 }
 TEST_CASE("moment_of_inertia type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::moment_of_inertia)>, mitama::quantity_t<std::decay_t<decltype(meter<2>*kilograms)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::moment_of_inertia)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<2>*kilograms)>>>);
 }
diff --git a/tests/format-io-tests/momentum-tests/momentum-tests.cpp b/tests/format-io-tests/momentum-tests/momentum-tests.cpp
index 26d26f8d..7290b60e 100644
--- a/tests/format-io-tests/momentum-tests/momentum-tests.cpp
+++ b/tests/format-io-tests/momentum-tests/momentum-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/momentum.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("momentum format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("momentum quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::momentum) == "1 [N s]");
 }
 TEST_CASE("momentum type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::momentum)>, mitama::quantity_t<std::decay_t<decltype(meters*kilograms*second<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::momentum)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meters*kilograms*second<-1>)>>>);
 }
diff --git a/tests/format-io-tests/named-test-gen.sh b/tests/format-io-tests/named-test-gen.sh
index e7732e39..2c3b5f50 100755
--- a/tests/format-io-tests/named-test-gen.sh
+++ b/tests/format-io-tests/named-test-gen.sh
@@ -6,6 +6,7 @@ cat <<EOS > $1-tests/$1-tests.cpp
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/$1.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("$2 format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/nonsi-tests/nonsi-tests.cpp b/tests/format-io-tests/nonsi-tests/nonsi-tests.cpp
index 5e9cb64e..3f3695d5 100644
--- a/tests/format-io-tests/nonsi-tests/nonsi-tests.cpp
+++ b/tests/format-io-tests/nonsi-tests/nonsi-tests.cpp
@@ -9,6 +9,7 @@
 #include <mitama/dimensional/systems/nonsi/minute.hpp>
 #include <mitama/dimensional/systems/nonsi/tonne.hpp>
 #include <mitama/dimensional/systems/nonsi/degree_celsius.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("hectare format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/optical_power-tests/optical_power-tests.cpp b/tests/format-io-tests/optical_power-tests/optical_power-tests.cpp
index e7978076..1ac1ad1e 100644
--- a/tests/format-io-tests/optical_power-tests/optical_power-tests.cpp
+++ b/tests/format-io-tests/optical_power-tests/optical_power-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/optical_power.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("optical_power format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("optical_power quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::optical_power) == "1 [m^-1]");
 }
 TEST_CASE("optical_power type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::optical_power)>, mitama::quantity_t<std::decay_t<decltype(meter<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::optical_power)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-1>)>>>);
 }
diff --git a/tests/format-io-tests/permeability-tests/permeability-tests.cpp b/tests/format-io-tests/permeability-tests/permeability-tests.cpp
index cd44dc7c..c60df7bb 100644
--- a/tests/format-io-tests/permeability-tests/permeability-tests.cpp
+++ b/tests/format-io-tests/permeability-tests/permeability-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/permeability.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("permeability format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("permeability quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::permeability) == "1 [H/m]");
 }
 TEST_CASE("permeability type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::permeability)>, mitama::quantity_t<std::decay_t<decltype(meter<>*kilogram<>*second<-2>*ampere<-2>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::permeability)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<>*kilogram<>*second<-2>*ampere<-2>)>>>);
 }
diff --git a/tests/format-io-tests/permittivity-tests/permittivity-tests.cpp b/tests/format-io-tests/permittivity-tests/permittivity-tests.cpp
index 9eedbb8c..6a6542a1 100644
--- a/tests/format-io-tests/permittivity-tests/permittivity-tests.cpp
+++ b/tests/format-io-tests/permittivity-tests/permittivity-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/permittivity.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("permittivity format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("permittivity quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::permittivity) == "1 [F/m]");
 }
 TEST_CASE("permittivity type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::permittivity)>, mitama::quantity_t<std::decay_t<decltype(meter<-3>*kilogram<-1>*second<4>*ampere<2>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::permittivity)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-3>*kilogram<-1>*second<4>*ampere<2>)>>>);
 }
diff --git a/tests/format-io-tests/polarization_density-tests/polarization_density-tests.cpp b/tests/format-io-tests/polarization_density-tests/polarization_density-tests.cpp
index 7c2c2088..91eb6107 100644
--- a/tests/format-io-tests/polarization_density-tests/polarization_density-tests.cpp
+++ b/tests/format-io-tests/polarization_density-tests/polarization_density-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/polarization_density.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("polarization_density format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("polarization_density quantifier format test", "[quantity][abbreviatio
   REQUIRE(fmt(1 | systems::si::polarization_density) == "1 [C/m^2]");
 }
 TEST_CASE("polarization_density type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::polarization_density)>, mitama::quantity_t<std::decay_t<decltype(meter<-2>*seconds*ampere<>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::polarization_density)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-2>*seconds*ampere<>)>>>);
 }
diff --git a/tests/format-io-tests/pop-tests/pop-tests.cpp b/tests/format-io-tests/pop-tests/pop-tests.cpp
index 48af89ec..2505b7d9 100644
--- a/tests/format-io-tests/pop-tests/pop-tests.cpp
+++ b/tests/format-io-tests/pop-tests/pop-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/pop.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("pop format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("pop quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::pop) == "1 [m/s^6]");
 }
 TEST_CASE("pop type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::pop)>, mitama::quantity_t<std::decay_t<decltype(meters/second<6>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::pop)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meters/second<6>)>>>);
 }
diff --git a/tests/format-io-tests/power-tests/power-tests.cpp b/tests/format-io-tests/power-tests/power-tests.cpp
index fe4ddb14..6fabcd47 100644
--- a/tests/format-io-tests/power-tests/power-tests.cpp
+++ b/tests/format-io-tests/power-tests/power-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/power.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("power_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/power_density-tests/power_density-tests.cpp b/tests/format-io-tests/power_density-tests/power_density-tests.cpp
index 33322e37..9d93b39b 100644
--- a/tests/format-io-tests/power_density-tests/power_density-tests.cpp
+++ b/tests/format-io-tests/power_density-tests/power_density-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/power_density.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("power_density format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("power_density quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::power_density) == "1 [W/m^3]");
 }
 TEST_CASE("power_density type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::power_density)>, mitama::quantity_t<std::decay_t<decltype(meter<-1>*kilograms*second<-3>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::power_density)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-1>*kilograms*second<-3>)>>>);
 }
diff --git a/tests/format-io-tests/pressure-tests/pressure-tests.cpp b/tests/format-io-tests/pressure-tests/pressure-tests.cpp
index f149ea11..757b48ee 100644
--- a/tests/format-io-tests/pressure-tests/pressure-tests.cpp
+++ b/tests/format-io-tests/pressure-tests/pressure-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/pressure.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("pressure_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/radiance-tests/radiance-tests.cpp b/tests/format-io-tests/radiance-tests/radiance-tests.cpp
index 557a1651..dd33ef99 100644
--- a/tests/format-io-tests/radiance-tests/radiance-tests.cpp
+++ b/tests/format-io-tests/radiance-tests/radiance-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/radiance.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("radiance format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("radiance quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::radiance) == "1 [W/(sr m^2)]");
 }
 TEST_CASE("radiance type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::radiance)>, mitama::quantity_t<std::decay_t<decltype(kilograms/steradian/second<3>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::radiance)>, mitama::systems::si::quantity_t<std::decay_t<decltype(kilograms/steradian/second<3>)>>>);
 }
diff --git a/tests/format-io-tests/radiant_exposure-tests/radiant_exposure-tests.cpp b/tests/format-io-tests/radiant_exposure-tests/radiant_exposure-tests.cpp
index bb764a7b..48a49a08 100644
--- a/tests/format-io-tests/radiant_exposure-tests/radiant_exposure-tests.cpp
+++ b/tests/format-io-tests/radiant_exposure-tests/radiant_exposure-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/radiant_exposure.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("radiant_exposure format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("radiant_exposure quantifier format test", "[quantity][abbreviation]")
   REQUIRE(fmt(1 | systems::si::radiant_exposure) == "1 [J/m^2]");
 }
 TEST_CASE("radiant_exposure type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::radiant_exposure)>, mitama::quantity_t<std::decay_t<decltype(kilograms*second<-2>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::radiant_exposure)>, mitama::systems::si::quantity_t<std::decay_t<decltype(kilograms*second<-2>)>>>);
 }
diff --git a/tests/format-io-tests/radiant_flux-tests/radiant_flux-tests.cpp b/tests/format-io-tests/radiant_flux-tests/radiant_flux-tests.cpp
index e60a5469..6bd7f19e 100644
--- a/tests/format-io-tests/radiant_flux-tests/radiant_flux-tests.cpp
+++ b/tests/format-io-tests/radiant_flux-tests/radiant_flux-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/radiant_flux.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("radiant_flux_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/radiant_intensity-tests/radiant_intensity-tests.cpp b/tests/format-io-tests/radiant_intensity-tests/radiant_intensity-tests.cpp
index 0346c0c1..95e19ecc 100644
--- a/tests/format-io-tests/radiant_intensity-tests/radiant_intensity-tests.cpp
+++ b/tests/format-io-tests/radiant_intensity-tests/radiant_intensity-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/radiant_intensity.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("radiant_intensity format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("radiant_intensity quantifier format test", "[quantity][abbreviation]"
   REQUIRE(fmt(1 | systems::si::radiant_intensity) == "1 [W/sr]");
 }
 TEST_CASE("radiant_intensity type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::radiant_intensity)>, mitama::quantity_t<std::decay_t<decltype(meter<2>*kilograms*second<-3>/steradian)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::radiant_intensity)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<2>*kilograms*second<-3>/steradian)>>>);
 }
diff --git a/tests/format-io-tests/radioactivity-tests/radioactivity-tests.cpp b/tests/format-io-tests/radioactivity-tests/radioactivity-tests.cpp
index 849ec594..a6dca193 100644
--- a/tests/format-io-tests/radioactivity-tests/radioactivity-tests.cpp
+++ b/tests/format-io-tests/radioactivity-tests/radioactivity-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/radioactivity.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("radioactivity_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/reactance-tests/reactance-tests.cpp b/tests/format-io-tests/reactance-tests/reactance-tests.cpp
index 25c3399c..ee1a4a0f 100644
--- a/tests/format-io-tests/reactance-tests/reactance-tests.cpp
+++ b/tests/format-io-tests/reactance-tests/reactance-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/reactance.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("reactance_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/resistance-tests/resistance-tests.cpp b/tests/format-io-tests/resistance-tests/resistance-tests.cpp
index b8cc0380..11b1753c 100644
--- a/tests/format-io-tests/resistance-tests/resistance-tests.cpp
+++ b/tests/format-io-tests/resistance-tests/resistance-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/resistance.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("resistance_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/resistivity-tests/resistivity-tests.cpp b/tests/format-io-tests/resistivity-tests/resistivity-tests.cpp
index 9cb7965d..3f9de64c 100644
--- a/tests/format-io-tests/resistivity-tests/resistivity-tests.cpp
+++ b/tests/format-io-tests/resistivity-tests/resistivity-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/resistivity.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("resistivity format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("resistivity quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::resistivity) == "1 [Ω m]");
 }
 TEST_CASE("resistivity type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::resistivity)>, mitama::quantity_t<std::decay_t<decltype(meter<3>*kilogram<>*second<-3>*ampere<-2>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::resistivity)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<3>*kilogram<>*second<-3>*ampere<-2>)>>>);
 }
diff --git a/tests/format-io-tests/snap-tests/snap-tests.cpp b/tests/format-io-tests/snap-tests/snap-tests.cpp
index 43a5c244..3085f2c9 100644
--- a/tests/format-io-tests/snap-tests/snap-tests.cpp
+++ b/tests/format-io-tests/snap-tests/snap-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/snap.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("snap format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("snap quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::snap) == "1 [m/s^4]");
 }
 TEST_CASE("snap type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::snap)>, mitama::quantity_t<std::decay_t<decltype(meters/second<4>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::snap)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meters/second<4>)>>>);
 }
diff --git a/tests/format-io-tests/solid_angle-tests/solid_angle-tests.cpp b/tests/format-io-tests/solid_angle-tests/solid_angle-tests.cpp
index 3117995f..dd6f7ce3 100644
--- a/tests/format-io-tests/solid_angle-tests/solid_angle-tests.cpp
+++ b/tests/format-io-tests/solid_angle-tests/solid_angle-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/solid_angle.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("steradian_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/spatial_frequency-tests/spatial_frequency-tests.cpp b/tests/format-io-tests/spatial_frequency-tests/spatial_frequency-tests.cpp
index 72708a7d..ea777f58 100644
--- a/tests/format-io-tests/spatial_frequency-tests/spatial_frequency-tests.cpp
+++ b/tests/format-io-tests/spatial_frequency-tests/spatial_frequency-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/spatial_frequency.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("spatial_frequency format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("spatial_frequency quantifier format test", "[quantity][abbreviation]"
   REQUIRE(fmt(1 | systems::si::spatial_frequency) == "1 [m^-1]");
 }
 TEST_CASE("spatial_frequency type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::spatial_frequency)>, mitama::quantity_t<std::decay_t<decltype(meter<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::spatial_frequency)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-1>)>>>);
 }
diff --git a/tests/format-io-tests/specific_angular_momentum-tests/specific_angular_momentum-tests.cpp b/tests/format-io-tests/specific_angular_momentum-tests/specific_angular_momentum-tests.cpp
index 5936472b..08e3e438 100644
--- a/tests/format-io-tests/specific_angular_momentum-tests/specific_angular_momentum-tests.cpp
+++ b/tests/format-io-tests/specific_angular_momentum-tests/specific_angular_momentum-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/specific_angular_momentum.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("specific_angular_momentum format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("specific_angular_momentum quantifier format test", "[quantity][abbrev
   REQUIRE(fmt(1 | systems::si::specific_angular_momentum) == "1 [N m s/kg]");
 }
 TEST_CASE("specific_angular_momentum type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::specific_angular_momentum)>, mitama::quantity_t<std::decay_t<decltype(meter<2>*second<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::specific_angular_momentum)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<2>*second<-1>)>>>);
 }
diff --git a/tests/format-io-tests/specific_energy-tests/specific_energy-tests.cpp b/tests/format-io-tests/specific_energy-tests/specific_energy-tests.cpp
index cbea53e4..f4c7f4cc 100644
--- a/tests/format-io-tests/specific_energy-tests/specific_energy-tests.cpp
+++ b/tests/format-io-tests/specific_energy-tests/specific_energy-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/specific_energy.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("specific_energy format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("specific_energy quantifier format test", "[quantity][abbreviation]")
   REQUIRE(fmt(1 | systems::si::specific_energy) == "1 [J/kg]");
 }
 TEST_CASE("specific_energy type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::specific_energy)>, mitama::quantity_t<std::decay_t<decltype(meter<2>*second<-2>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::specific_energy)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<2>*second<-2>)>>>);
 }
diff --git a/tests/format-io-tests/specific_entropy-tests/specific_entropy-tests.cpp b/tests/format-io-tests/specific_entropy-tests/specific_entropy-tests.cpp
index c1886a38..71ef9426 100644
--- a/tests/format-io-tests/specific_entropy-tests/specific_entropy-tests.cpp
+++ b/tests/format-io-tests/specific_entropy-tests/specific_entropy-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/specific_entropy.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("specific_entropy format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("specific_entropy quantifier format test", "[quantity][abbreviation]")
   REQUIRE(fmt(1 | systems::si::specific_entropy) == "1 [J/(K⋅kg)]");
 }
 TEST_CASE("specific_entropy type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::specific_entropy)>, mitama::quantity_t<std::decay_t<decltype(meter<2>*second<-2>*kelvin<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::specific_entropy)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<2>*second<-2>*kelvin<-1>)>>>);
 }
diff --git a/tests/format-io-tests/specific_heat_capacity-tests/specific_heat_capacity-tests.cpp b/tests/format-io-tests/specific_heat_capacity-tests/specific_heat_capacity-tests.cpp
index aac0bddc..52c09af0 100644
--- a/tests/format-io-tests/specific_heat_capacity-tests/specific_heat_capacity-tests.cpp
+++ b/tests/format-io-tests/specific_heat_capacity-tests/specific_heat_capacity-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/specific_heat_capacity.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("specific_heat_capacity format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("specific_heat_capacity quantifier format test", "[quantity][abbreviat
   REQUIRE(fmt(1 | systems::si::specific_heat_capacity) == "1 [J/(K kg)]");
 }
 TEST_CASE("specific_heat_capacity type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::specific_heat_capacity)>, mitama::quantity_t<std::decay_t<decltype(meter<2>*second<-2>*kelvin<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::specific_heat_capacity)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<2>*second<-2>*kelvin<-1>)>>>);
 }
diff --git a/tests/format-io-tests/specific_volume-tests/specific_volume-tests.cpp b/tests/format-io-tests/specific_volume-tests/specific_volume-tests.cpp
index 64c6a017..d389f5a8 100644
--- a/tests/format-io-tests/specific_volume-tests/specific_volume-tests.cpp
+++ b/tests/format-io-tests/specific_volume-tests/specific_volume-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/specific_volume.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("specific_volume format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("specific_volume quantifier format test", "[quantity][abbreviation]")
   REQUIRE(fmt(1 | systems::si::specific_volume) == "1 [m^3/kg]");
 }
 TEST_CASE("specific_volume type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::specific_volume)>, mitama::quantity_t<std::decay_t<decltype(meter<3>*kilogram<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::specific_volume)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<3>*kilogram<-1>)>>>);
 }
diff --git a/tests/format-io-tests/spectral_intensity-tests/spectral_intensity-tests.cpp b/tests/format-io-tests/spectral_intensity-tests/spectral_intensity-tests.cpp
index 2b85273a..2cc8ea8c 100644
--- a/tests/format-io-tests/spectral_intensity-tests/spectral_intensity-tests.cpp
+++ b/tests/format-io-tests/spectral_intensity-tests/spectral_intensity-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/spectral_intensity.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("spectral_intensity format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("spectral_intensity quantifier format test", "[quantity][abbreviation]
   REQUIRE(fmt(1 | systems::si::spectral_intensity) == "1 [W/(sr m)]");
 }
 TEST_CASE("spectral_intensity type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::spectral_intensity)>, mitama::quantity_t<std::decay_t<decltype(meters*kilograms*second<-3>/steradian)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::spectral_intensity)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meters*kilograms*second<-3>/steradian)>>>);
 }
diff --git a/tests/format-io-tests/spectral_irradiance-tests/spectral_irradiance-tests.cpp b/tests/format-io-tests/spectral_irradiance-tests/spectral_irradiance-tests.cpp
index 6fab62db..2d7954d3 100644
--- a/tests/format-io-tests/spectral_irradiance-tests/spectral_irradiance-tests.cpp
+++ b/tests/format-io-tests/spectral_irradiance-tests/spectral_irradiance-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/spectral_irradiance.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("spectral_irradiance format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("spectral_irradiance quantifier format test", "[quantity][abbreviation
   REQUIRE(fmt(1 | systems::si::spectral_irradiance) == "1 [W/m^3]");
 }
 TEST_CASE("spectral_irradiance type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::spectral_irradiance)>, mitama::quantity_t<std::decay_t<decltype(meter<-1>*kilograms*second<-3>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::spectral_irradiance)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-1>*kilograms*second<-3>)>>>);
 }
diff --git a/tests/format-io-tests/spectral_power-tests/spectral_power-tests.cpp b/tests/format-io-tests/spectral_power-tests/spectral_power-tests.cpp
index 4e201bf3..42b3799c 100644
--- a/tests/format-io-tests/spectral_power-tests/spectral_power-tests.cpp
+++ b/tests/format-io-tests/spectral_power-tests/spectral_power-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/spectral_power.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("spectral_power format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("spectral_power quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::spectral_power) == "1 [W/m]");
 }
 TEST_CASE("spectral_power type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::spectral_power)>, mitama::quantity_t<std::decay_t<decltype(meters*kilograms*second<-3>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::spectral_power)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meters*kilograms*second<-3>)>>>);
 }
diff --git a/tests/format-io-tests/spectral_radiance-tests/spectral_radiance-tests.cpp b/tests/format-io-tests/spectral_radiance-tests/spectral_radiance-tests.cpp
index fcebc91b..903602e7 100644
--- a/tests/format-io-tests/spectral_radiance-tests/spectral_radiance-tests.cpp
+++ b/tests/format-io-tests/spectral_radiance-tests/spectral_radiance-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/spectral_radiance.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("spectral_radiance format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("spectral_radiance quantifier format test", "[quantity][abbreviation]"
   REQUIRE(fmt(1 | systems::si::spectral_radiance) == "1 [W/(sr m^3)]");
 }
 TEST_CASE("spectral_radiance type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::spectral_radiance)>, mitama::quantity_t<std::decay_t<decltype(meter<-1>*kilograms*second<-3>/steradian)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::spectral_radiance)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-1>*kilograms*second<-3>/steradian)>>>);
 }
diff --git a/tests/format-io-tests/surface_tension-tests/surface_tension-tests.cpp b/tests/format-io-tests/surface_tension-tests/surface_tension-tests.cpp
index a8906271..1ab9f0c0 100644
--- a/tests/format-io-tests/surface_tension-tests/surface_tension-tests.cpp
+++ b/tests/format-io-tests/surface_tension-tests/surface_tension-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/surface_tension.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("surface_tension format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("surface_tension quantifier format test", "[quantity][abbreviation]")
   REQUIRE(fmt(1 | systems::si::surface_tension) == "1 [N/m]");
 }
 TEST_CASE("surface_tension type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::surface_tension)>, mitama::quantity_t<std::decay_t<decltype(kilograms*second<-2>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::surface_tension)>, mitama::systems::si::quantity_t<std::decay_t<decltype(kilograms*second<-2>)>>>);
 }
diff --git a/tests/format-io-tests/temperature_gradient-tests/temperature_gradient-tests.cpp b/tests/format-io-tests/temperature_gradient-tests/temperature_gradient-tests.cpp
index 70772938..4dda161c 100644
--- a/tests/format-io-tests/temperature_gradient-tests/temperature_gradient-tests.cpp
+++ b/tests/format-io-tests/temperature_gradient-tests/temperature_gradient-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/temperature_gradient.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("temperature_gradient format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("temperature_gradient quantifier format test", "[quantity][abbreviatio
   REQUIRE(fmt(1 | systems::si::temperature_gradient) == "1 [K/m]");
 }
 TEST_CASE("temperature_gradient type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::temperature_gradient)>, mitama::quantity_t<std::decay_t<decltype(meter<-1>*kelvins)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::temperature_gradient)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-1>*kelvins)>>>);
 }
diff --git a/tests/format-io-tests/thermal_conductivity-tests/thermal_conductivity-tests.cpp b/tests/format-io-tests/thermal_conductivity-tests/thermal_conductivity-tests.cpp
index 201c105b..7e96ebf0 100644
--- a/tests/format-io-tests/thermal_conductivity-tests/thermal_conductivity-tests.cpp
+++ b/tests/format-io-tests/thermal_conductivity-tests/thermal_conductivity-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/thermal_conductivity.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("thermal_conductivity format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("thermal_conductivity quantifier format test", "[quantity][abbreviatio
   REQUIRE(fmt(1 | systems::si::thermal_conductivity) == "1 [W/(m K)]");
 }
 TEST_CASE("thermal_conductivity type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::thermal_conductivity)>, mitama::quantity_t<std::decay_t<decltype(meter<>*kilograms*second<-3>*kelvin<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::thermal_conductivity)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<>*kilograms*second<-3>*kelvin<-1>)>>>);
 }
diff --git a/tests/format-io-tests/thermal_diffusivity-tests/thermal_diffusivity-tests.cpp b/tests/format-io-tests/thermal_diffusivity-tests/thermal_diffusivity-tests.cpp
index ebecacd9..d26ffddc 100644
--- a/tests/format-io-tests/thermal_diffusivity-tests/thermal_diffusivity-tests.cpp
+++ b/tests/format-io-tests/thermal_diffusivity-tests/thermal_diffusivity-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/thermal_diffusivity.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("thermal_diffusivity format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("thermal_diffusivity quantifier format test", "[quantity][abbreviation
   REQUIRE(fmt(1 | systems::si::thermal_diffusivity) == "1 [m^2/s]");
 }
 TEST_CASE("thermal_diffusivity type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::thermal_diffusivity)>, mitama::quantity_t<std::decay_t<decltype(meter<2>*second<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::thermal_diffusivity)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<2>*second<-1>)>>>);
 }
diff --git a/tests/format-io-tests/thermal_expansion_coefficient-tests/thermal_expansion_coefficient-tests.cpp b/tests/format-io-tests/thermal_expansion_coefficient-tests/thermal_expansion_coefficient-tests.cpp
index 643c059f..0f62e06a 100644
--- a/tests/format-io-tests/thermal_expansion_coefficient-tests/thermal_expansion_coefficient-tests.cpp
+++ b/tests/format-io-tests/thermal_expansion_coefficient-tests/thermal_expansion_coefficient-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/thermal_expansion_coefficient.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("thermal_expansion_coefficient format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("thermal_expansion_coefficient quantifier format test", "[quantity][ab
   REQUIRE(fmt(1 | systems::si::thermal_expansion_coefficient) == "1 [K^-1]");
 }
 TEST_CASE("thermal_expansion_coefficient type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::thermal_expansion_coefficient)>, mitama::quantity_t<std::decay_t<decltype(kelvin<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::thermal_expansion_coefficient)>, mitama::systems::si::quantity_t<std::decay_t<decltype(kelvin<-1>)>>>);
 }
diff --git a/tests/format-io-tests/thermal_resistance-tests/thermal_resistance-tests.cpp b/tests/format-io-tests/thermal_resistance-tests/thermal_resistance-tests.cpp
index cf383e7b..9a334967 100644
--- a/tests/format-io-tests/thermal_resistance-tests/thermal_resistance-tests.cpp
+++ b/tests/format-io-tests/thermal_resistance-tests/thermal_resistance-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/thermal_resistance.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("thermal_resistance format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("thermal_resistance quantifier format test", "[quantity][abbreviation]
   REQUIRE(fmt(1 | systems::si::thermal_resistance) == "1 [K/W]");
 }
 TEST_CASE("thermal_resistance type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::thermal_resistance)>, mitama::quantity_t<std::decay_t<decltype(meter<-2>*kilogram<-1>*second<3>*kelvins)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::thermal_resistance)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-2>*kilogram<-1>*second<3>*kelvins)>>>);
 }
diff --git a/tests/format-io-tests/torque-tests/torque-tests.cpp b/tests/format-io-tests/torque-tests/torque-tests.cpp
index 589ceb73..35fcabaf 100644
--- a/tests/format-io-tests/torque-tests/torque-tests.cpp
+++ b/tests/format-io-tests/torque-tests/torque-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/torque.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("torque format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("torque quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::torque) == "1 [N m]");
 }
 TEST_CASE("torque type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::torque)>, mitama::quantity_t<std::decay_t<decltype(meter<2>*kilograms*second<-2>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::torque)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<2>*kilograms*second<-2>)>>>);
 }
diff --git a/tests/format-io-tests/velocity-tests/velocity-tests.cpp b/tests/format-io-tests/velocity-tests/velocity-tests.cpp
index 47e12fce..dfedacea 100644
--- a/tests/format-io-tests/velocity-tests/velocity-tests.cpp
+++ b/tests/format-io-tests/velocity-tests/velocity-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/velocity.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("velocity format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("velocity quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::velocity) == "1 [m/s]");
 }
 TEST_CASE("velocity type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::velocity)>, mitama::quantity_t<std::decay_t<decltype(meters/seconds)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::velocity)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meters/seconds)>>>);
 }
diff --git a/tests/format-io-tests/voltage-tests/voltage-tests.cpp b/tests/format-io-tests/voltage-tests/voltage-tests.cpp
index fcfd745f..b76735db 100644
--- a/tests/format-io-tests/voltage-tests/voltage-tests.cpp
+++ b/tests/format-io-tests/voltage-tests/voltage-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/voltage.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("voltage_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/volume-tests/volume-tests.cpp b/tests/format-io-tests/volume-tests/volume-tests.cpp
index 20f14245..675f2cbb 100644
--- a/tests/format-io-tests/volume-tests/volume-tests.cpp
+++ b/tests/format-io-tests/volume-tests/volume-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/volume.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("volume format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("volume quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::volume) == "1 [m^3]");
 }
 TEST_CASE("volume type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::volume)>, mitama::quantity_t<std::decay_t<decltype(meter<3>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::volume)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<3>)>>>);
 }
diff --git a/tests/format-io-tests/volumetric_flow-tests/volumetric_flow-tests.cpp b/tests/format-io-tests/volumetric_flow-tests/volumetric_flow-tests.cpp
index 6f34eb02..ddca51d7 100644
--- a/tests/format-io-tests/volumetric_flow-tests/volumetric_flow-tests.cpp
+++ b/tests/format-io-tests/volumetric_flow-tests/volumetric_flow-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/volumetric_flow.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("volumetric_flow format test", "[quantity][abbreviation]") {
@@ -10,5 +11,5 @@ TEST_CASE("volumetric_flow quantifier format test", "[quantity][abbreviation]")
   REQUIRE(fmt(1 | systems::si::volumetric_flow) == "1 [m^3/s]");
 }
 TEST_CASE("volumetric_flow type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::volumetric_flow)>, mitama::quantity_t<std::decay_t<decltype(meter<3>*second<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::volumetric_flow)>, mitama::systems::si::quantity_t<std::decay_t<decltype(meter<3>*second<-1>)>>>);
 }
diff --git a/tests/format-io-tests/wavenumber-tests/wavenumber-tests.cpp b/tests/format-io-tests/wavenumber-tests/wavenumber-tests.cpp
index e54dcb7d..fd8f2d23 100644
--- a/tests/format-io-tests/wavenumber-tests/wavenumber-tests.cpp
+++ b/tests/format-io-tests/wavenumber-tests/wavenumber-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/wavenumber.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("wavenumber format test", "[quantity][abbreviation]") {
@@ -10,5 +11,7 @@ TEST_CASE("wavenumber quantifier format test", "[quantity][abbreviation]") {
   REQUIRE(fmt(1 | systems::si::wavenumber) == "1 [m^-1]");
 }
 TEST_CASE("wavenumber type test", "[quantity][abbreviation]") {
-  REQUIRE(mitama::is_same_dimensional_v<std::decay_t<decltype(1|systems::si::wavenumber)>, mitama::quantity_t<std::decay_t<decltype(meter<-1>)>>>);
+  REQUIRE(mitama::is_same_dimensional_v<
+    std::decay_t<decltype(1|systems::si::wavenumber)>,
+    mitama::systems::si::quantity_t<std::decay_t<decltype(meter<-1>)>>>);
 }
diff --git a/tests/format-io-tests/weight-tests/weight-tests.cpp b/tests/format-io-tests/weight-tests/weight-tests.cpp
index 63624812..8d703e05 100644
--- a/tests/format-io-tests/weight-tests/weight-tests.cpp
+++ b/tests/format-io-tests/weight-tests/weight-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/weight.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("weight_t format test", "[quantity][abbreviation]") {
diff --git a/tests/format-io-tests/work-tests/work-tests.cpp b/tests/format-io-tests/work-tests/work-tests.cpp
index 9e9f6bc1..40924def 100644
--- a/tests/format-io-tests/work-tests/work-tests.cpp
+++ b/tests/format-io-tests/work-tests/work-tests.cpp
@@ -1,6 +1,7 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 #include <mitama/dimensional/systems/si/derived_units/work.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
 #include "../format_io_common.hpp"
 
 TEST_CASE("work_t format test", "[quantity][abbreviation]") {
diff --git a/tests/literal-tests/CMakeLists.txt b/tests/literal-tests/CMakeLists.txt
new file mode 100644
index 00000000..637b58d9
--- /dev/null
+++ b/tests/literal-tests/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(si-basics)
diff --git a/tests/literal-tests/si-basics/CMakeLists.txt b/tests/literal-tests/si-basics/CMakeLists.txt
new file mode 100644
index 00000000..ca2f01ca
--- /dev/null
+++ b/tests/literal-tests/si-basics/CMakeLists.txt
@@ -0,0 +1,13 @@
+message(STATUS "Building test for si-literals")
+
+set(target tests-for-si-literals)
+message(STATUS "Building library ${target}")
+
+set(sources
+    tests-main.cpp
+    ampere-tests.cpp
+    # candela-tests.cpp
+)
+add_executable(${target} ${sources})
+add_test(literal-tests "${EXECUTABLE_OUTPUT_PATH}/${target}")
+set_tests_properties(literal-tests PROPERTIES LABELS "arithmetic")
diff --git a/tests/literal-tests/si-basics/ampere-tests.cpp b/tests/literal-tests/si-basics/ampere-tests.cpp
new file mode 100644
index 00000000..44be8e69
--- /dev/null
+++ b/tests/literal-tests/si-basics/ampere-tests.cpp
@@ -0,0 +1,60 @@
+// main is provided in tests-main.cpp
+#include <catch2/catch.hpp>
+#include <mitama/dimensional/systems/si/quantity.hpp>
+#include <mitama/dimensional/systems/si/prefix.hpp>
+#include <mitama/dimensional/arithmetic.hpp>
+#include <test_util.hpp>
+
+namespace si = mitama::systems::si;
+
+#include <mitama/dimensional/systems/si/literals/ampere_literals.hpp>
+
+TEST_CASE("ampere literals",
+          "[quantity][literals]")
+{
+    using namespace mitama::literals;
+    REQUIRE(std::is_same_v<
+        decltype(1.0_A),
+        si::quantity_t<si::ampere_t, long double>
+    >);
+}
+
+TEST_CASE("milli-ampere literals",
+          "[quantity][literals]")
+{
+    using namespace mitama::literals;
+    REQUIRE(std::is_same_v<
+        decltype(1.0_mA),
+        si::quantity_t<si::milliampere_t, long double>
+    >);
+}
+
+TEST_CASE("micro-ampere literals",
+          "[quantity][literals]")
+{
+    using namespace mitama::literals;
+    REQUIRE(std::is_same_v<
+        decltype(1.0_uA),
+        si::quantity_t<si::microampere_t, long double>
+    >);
+}
+
+TEST_CASE("kilo-ampere literals",
+          "[quantity][literals]")
+{
+    using namespace mitama::literals;
+    REQUIRE(std::is_same_v<
+        decltype(1.0_kA),
+        si::quantity_t<si::kiloampere_t, long double>
+    >);
+}
+
+TEST_CASE("mega-ampere literals",
+          "[quantity][literals]")
+{
+    using namespace mitama::literals;
+    REQUIRE(std::is_same_v<
+        decltype(1.0_MA),
+        si::quantity_t<si::megaampere_t, long double>
+    >);
+}
diff --git a/tests/static-quantity-tests/tests-main.cpp b/tests/literal-tests/si-basics/tests-main.cpp
similarity index 100%
rename from tests/static-quantity-tests/tests-main.cpp
rename to tests/literal-tests/si-basics/tests-main.cpp
diff --git a/tests/math-tests/math-tests.cpp b/tests/math-tests/math-tests.cpp
index 7ae282b5..832b8e4f 100644
--- a/tests/math-tests/math-tests.cpp
+++ b/tests/math-tests/math-tests.cpp
@@ -5,7 +5,6 @@
 #include <mitama/dimensional/systems/si/prefix.hpp>
 #include <random>
 #include <test_util.hpp>
-#include <mitama/dimensional/expr.hpp>
 #include <mitama/dimensional/arithmetic.hpp>
 #include <mitama/dimensional/math/all.hpp>
 #include <mitama/dimensional/systems/si/derived_units/angle.hpp>
diff --git a/tests/nonsi-unit-tests/nonsi-unit-tests.cpp b/tests/nonsi-unit-tests/nonsi-unit-tests.cpp
index 5437a56a..c1e5941d 100644
--- a/tests/nonsi-unit-tests/nonsi-unit-tests.cpp
+++ b/tests/nonsi-unit-tests/nonsi-unit-tests.cpp
@@ -6,7 +6,6 @@
 #include <mitama/dimensional/systems/si/prefix.hpp>
 #include <random>
 #include <test_util.hpp>
-#include <mitama/dimensional/expr.hpp>
 #include <mitama/dimensional/arithmetic.hpp>
 
 using namespace mitama;
diff --git a/tests/refinement-tests/CMakeLists.txt b/tests/refinement-tests/CMakeLists.txt
deleted file mode 100644
index c0cadb00..00000000
--- a/tests/refinement-tests/CMakeLists.txt
+++ /dev/null
@@ -1,120 +0,0 @@
-add_subdirectory(./surface_tension-tests)
-add_subdirectory(./electron_mobility-tests)
-add_subdirectory(./angular_velocity-tests)
-add_subdirectory(./specific_heat_capacity-tests)
-add_subdirectory(./conductance-tests)
-add_subdirectory(./momentum-tests)
-add_subdirectory(./molar_energy-tests)
-add_subdirectory(./illuminance-tests)
-add_subdirectory(./pop-tests)
-add_subdirectory(./snap-tests)
-add_subdirectory(./crackle-tests)
-add_subdirectory(./catalytic_efficiency-tests)
-add_subdirectory(./action-tests)
-add_subdirectory(./mass_flow_rate-tests)
-add_subdirectory(./radiant_flux-tests)
-add_subdirectory(./heat_capacity-tests)
-add_subdirectory(./curvature-tests)
-add_subdirectory(./spectral_power-tests)
-add_subdirectory(./force-tests)
-add_subdirectory(./jerk-tests)
-add_subdirectory(./specific_energy-tests)
-add_subdirectory(./weight-tests)
-add_subdirectory(./magnetic_reluctance-tests)
-add_subdirectory(./magnetic_dipole_moment-tests)
-add_subdirectory(./magnetomotive_force-tests)
-add_subdirectory(./spectral_radiance-tests)
-add_subdirectory(./magnetic_rigidity-tests)
-add_subdirectory(./kinematic_viscosity-tests)
-add_subdirectory(./temperature_gradient-tests)
-add_subdirectory(./spectral_intensity-tests)
-add_subdirectory(./magnetic_vector_potential-tests)
-add_subdirectory(./irradiance-tests)
-add_subdirectory(./permeability-tests)
-add_subdirectory(./specific_angular_momentum-tests)
-add_subdirectory(./radiance-tests)
-add_subdirectory(./magnetic_flux_density-tests)
-add_subdirectory(./impedance-tests)
-add_subdirectory(./power_density-tests)
-add_subdirectory(./electrical_conductivity-tests)
-add_subdirectory(./heat_flux-tests)
-add_subdirectory(./magnetic_susceptibility-tests)
-add_subdirectory(./frequency-tests)
-add_subdirectory(./electric_field_strength-tests)
-add_subdirectory(./wavenumber-tests)
-add_subdirectory(./luminous_efficacy-tests)
-add_subdirectory(./linear_charge_density-tests)
-add_subdirectory(./magnetic_field_strength-tests)
-add_subdirectory(./radiant_exposure-tests)
-add_subdirectory(./absorbed_dose_rate-tests)
-add_subdirectory(./molar_entropy-tests)
-add_subdirectory(./resistivity-tests)
-add_subdirectory(./torque-tests)
-add_subdirectory(./area-tests)
-add_subdirectory(./permittivity-tests)
-add_subdirectory(./voltage-tests)
-add_subdirectory(./dynamic_viscosity-tests)
-add_subdirectory(./velocity-tests)
-add_subdirectory(./radiant_intensity-tests)
-add_subdirectory(./catalytic_activity-tests)
-add_subdirectory(./molar_mass-tests)
-add_subdirectory(./heat-tests)
-add_subdirectory(./solid_angle-tests)
-add_subdirectory(./molar_volume-tests)
-add_subdirectory(./thermal_diffusivity-tests)
-add_subdirectory(./molar_heat_capacity-tests)
-add_subdirectory(./capacitance-tests)
-add_subdirectory(./compressibility-tests)
-add_subdirectory(./power-tests)
-add_subdirectory(./specific_entropy-tests)
-add_subdirectory(./heat_flux_density-tests)
-add_subdirectory(./volume-tests)
-add_subdirectory(./impulse-tests)
-add_subdirectory(./angular_acceleration-tests)
-add_subdirectory(./energy_flux_density-tests)
-add_subdirectory(./molarity-tests)
-add_subdirectory(./specific_volume-tests)
-add_subdirectory(./entropy-tests)
-add_subdirectory(./inductance-tests)
-add_subdirectory(./spectral_irradiance-tests)
-add_subdirectory(./equivalent_dose-tests)
-add_subdirectory(./diffusion_coefficient-tests)
-add_subdirectory(./molar_conductivity-tests)
-add_subdirectory(./magnetization-tests)
-add_subdirectory(./angular_momentum-tests)
-add_subdirectory(./moment_of_inertia-tests)
-add_subdirectory(./electric_current_density-tests)
-add_subdirectory(./electric_potential-tests)
-add_subdirectory(./radioactivity-tests)
-add_subdirectory(./energy-tests)
-add_subdirectory(./frequency_drift-tests)
-add_subdirectory(./luminous_flux-tests)
-add_subdirectory(./linear_mass_density-tests)
-add_subdirectory(./stiffness-tests)
-add_subdirectory(./density-tests)
-add_subdirectory(./electric_displacement_field-tests)
-add_subdirectory(./magnetic_moment-tests)
-add_subdirectory(./angle-tests)
-add_subdirectory(./magnetic_flux-tests)
-add_subdirectory(./reactance-tests)
-add_subdirectory(./resistance-tests)
-add_subdirectory(./optical_power-tests)
-add_subdirectory(./volumetric_flow-tests)
-add_subdirectory(./luminous_energy-tests)
-add_subdirectory(./work-tests)
-add_subdirectory(./molality-tests)
-add_subdirectory(./spatial_frequency-tests)
-add_subdirectory(./area_density-tests)
-add_subdirectory(./thermal_expansion_coefficient-tests)
-add_subdirectory(./luminous_exposure-tests)
-add_subdirectory(./acceleration-tests)
-add_subdirectory(./exposure-tests)
-add_subdirectory(./electric_charge-tests)
-add_subdirectory(./luminance-tests)
-add_subdirectory(./fuel_efficiency-tests)
-add_subdirectory(./pressure-tests)
-add_subdirectory(./absorbed_dose-tests)
-add_subdirectory(./thermal_resistance-tests)
-add_subdirectory(./energy_density-tests)
-add_subdirectory(./thermal_conductivity-tests)
-add_subdirectory(./polarization_density-tests)
diff --git a/tests/refinement-tests/absorbed_dose-tests/CMakeLists.txt b/tests/refinement-tests/absorbed_dose-tests/CMakeLists.txt
deleted file mode 100644
index b0420039..00000000
--- a/tests/refinement-tests/absorbed_dose-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building absorbed_dose test")
-
-set(target absorbed_dose-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources absorbed_dose-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(absorbed_dose "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(absorbed_dose PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/absorbed_dose-tests/absorbed_dose-tests.cpp b/tests/refinement-tests/absorbed_dose-tests/absorbed_dose-tests.cpp
deleted file mode 100644
index b027e344..00000000
--- a/tests/refinement-tests/absorbed_dose-tests/absorbed_dose-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/absorbed_dose.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("absorbed_dose refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::absorbed_dose_r> |= quantity_t<systems::si::absorbed_dose_t>{}) == quantity_t<systems::si::absorbed_dose_t>{});
-}
-
diff --git a/tests/refinement-tests/absorbed_dose_rate-tests/CMakeLists.txt b/tests/refinement-tests/absorbed_dose_rate-tests/CMakeLists.txt
deleted file mode 100644
index 9ac5d023..00000000
--- a/tests/refinement-tests/absorbed_dose_rate-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building absorbed_dose_rate test")
-
-set(target absorbed_dose_rate-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources absorbed_dose_rate-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(absorbed_dose_rate "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(absorbed_dose_rate PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/absorbed_dose_rate-tests/absorbed_dose_rate-tests.cpp b/tests/refinement-tests/absorbed_dose_rate-tests/absorbed_dose_rate-tests.cpp
deleted file mode 100644
index 89b6934b..00000000
--- a/tests/refinement-tests/absorbed_dose_rate-tests/absorbed_dose_rate-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/absorbed_dose_rate.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("absorbed_dose_rate refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::absorbed_dose_rate_r> |= quantity_t<systems::si::absorbed_dose_rate_t>{}) == quantity_t<systems::si::absorbed_dose_rate_t>{});
-}
-
diff --git a/tests/refinement-tests/acceleration-tests/CMakeLists.txt b/tests/refinement-tests/acceleration-tests/CMakeLists.txt
deleted file mode 100644
index 41ebe176..00000000
--- a/tests/refinement-tests/acceleration-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building acceleration test")
-
-set(target acceleration-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources acceleration-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(acceleration "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(acceleration PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/acceleration-tests/acceleration-tests.cpp b/tests/refinement-tests/acceleration-tests/acceleration-tests.cpp
deleted file mode 100644
index 64743b12..00000000
--- a/tests/refinement-tests/acceleration-tests/acceleration-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/acceleration.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("acceleration refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::acceleration_r> |= quantity_t<systems::si::acceleration_t>{}) == quantity_t<systems::si::acceleration_t>{});
-}
-
diff --git a/tests/refinement-tests/action-tests/CMakeLists.txt b/tests/refinement-tests/action-tests/CMakeLists.txt
deleted file mode 100644
index 79404592..00000000
--- a/tests/refinement-tests/action-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building action test")
-
-set(target action-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources action-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(action "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(action PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/action-tests/action-tests.cpp b/tests/refinement-tests/action-tests/action-tests.cpp
deleted file mode 100644
index 09119fb6..00000000
--- a/tests/refinement-tests/action-tests/action-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/action.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("action refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::action_r> |= quantity_t<systems::si::action_t>{}) == quantity_t<systems::si::action_t>{});
-}
-
diff --git a/tests/refinement-tests/angle-tests/CMakeLists.txt b/tests/refinement-tests/angle-tests/CMakeLists.txt
deleted file mode 100644
index 1ae4837b..00000000
--- a/tests/refinement-tests/angle-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building angle test")
-
-set(target angle-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources angle-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(angle "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(angle PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/angle-tests/angle-tests.cpp b/tests/refinement-tests/angle-tests/angle-tests.cpp
deleted file mode 100644
index a914b143..00000000
--- a/tests/refinement-tests/angle-tests/angle-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/angle.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("angle refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::radian_r> |= quantity_t<systems::si::radian_t>{}) == quantity_t<systems::si::radian_t>{});
-}
-
diff --git a/tests/refinement-tests/angular_acceleration-tests/CMakeLists.txt b/tests/refinement-tests/angular_acceleration-tests/CMakeLists.txt
deleted file mode 100644
index 8c0bf93e..00000000
--- a/tests/refinement-tests/angular_acceleration-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building angular_acceleration test")
-
-set(target angular_acceleration-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources angular_acceleration-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(angular_acceleration "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(angular_acceleration PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/angular_acceleration-tests/angular_acceleration-tests.cpp b/tests/refinement-tests/angular_acceleration-tests/angular_acceleration-tests.cpp
deleted file mode 100644
index a57d5ba6..00000000
--- a/tests/refinement-tests/angular_acceleration-tests/angular_acceleration-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/angular_acceleration.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("angular_acceleration refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::angular_acceleration_r> |= quantity_t<systems::si::angular_acceleration_t>{}) == quantity_t<systems::si::angular_acceleration_t>{});
-}
-
diff --git a/tests/refinement-tests/angular_momentum-tests/CMakeLists.txt b/tests/refinement-tests/angular_momentum-tests/CMakeLists.txt
deleted file mode 100644
index 84636860..00000000
--- a/tests/refinement-tests/angular_momentum-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building angular_momentum test")
-
-set(target angular_momentum-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources angular_momentum-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(angular_momentum "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(angular_momentum PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/angular_momentum-tests/angular_momentum-tests.cpp b/tests/refinement-tests/angular_momentum-tests/angular_momentum-tests.cpp
deleted file mode 100644
index 97abd37b..00000000
--- a/tests/refinement-tests/angular_momentum-tests/angular_momentum-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/angular_momentum.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("angular_momentum refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::angular_momentum_r> |= quantity_t<systems::si::angular_momentum_t>{}) == quantity_t<systems::si::angular_momentum_t>{});
-}
-
diff --git a/tests/refinement-tests/angular_velocity-tests/CMakeLists.txt b/tests/refinement-tests/angular_velocity-tests/CMakeLists.txt
deleted file mode 100644
index 0145bdce..00000000
--- a/tests/refinement-tests/angular_velocity-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building angular_velocity test")
-
-set(target angular_velocity-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources angular_velocity-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(angular_velocity "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(angular_velocity PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/angular_velocity-tests/angular_velocity-tests.cpp b/tests/refinement-tests/angular_velocity-tests/angular_velocity-tests.cpp
deleted file mode 100644
index c8542044..00000000
--- a/tests/refinement-tests/angular_velocity-tests/angular_velocity-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/angular_velocity.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("angular_velocity refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::angular_velocity_r> |= quantity_t<systems::si::angular_velocity_t>{}) == quantity_t<systems::si::angular_velocity_t>{});
-}
-
diff --git a/tests/refinement-tests/area-tests/CMakeLists.txt b/tests/refinement-tests/area-tests/CMakeLists.txt
deleted file mode 100644
index 444701d5..00000000
--- a/tests/refinement-tests/area-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building area test")
-
-set(target area-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources area-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(area "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(area PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/area-tests/area-tests.cpp b/tests/refinement-tests/area-tests/area-tests.cpp
deleted file mode 100644
index 3b62b2d3..00000000
--- a/tests/refinement-tests/area-tests/area-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/area.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("area refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::area_r> |= quantity_t<systems::si::area_t>{}) == quantity_t<systems::si::area_t>{});
-}
-
diff --git a/tests/refinement-tests/area_density-tests/CMakeLists.txt b/tests/refinement-tests/area_density-tests/CMakeLists.txt
deleted file mode 100644
index e2841a65..00000000
--- a/tests/refinement-tests/area_density-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building area_density test")
-
-set(target area_density-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources area_density-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(area_density "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(area_density PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/area_density-tests/area_density-tests.cpp b/tests/refinement-tests/area_density-tests/area_density-tests.cpp
deleted file mode 100644
index ae1a2abd..00000000
--- a/tests/refinement-tests/area_density-tests/area_density-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/area_density.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("area_density refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::area_density_r> |= quantity_t<systems::si::area_density_t>{}) == quantity_t<systems::si::area_density_t>{});
-}
-
diff --git a/tests/refinement-tests/basic-tests/CMakeLists.txt b/tests/refinement-tests/basic-tests/CMakeLists.txt
deleted file mode 100644
index 1e8238b1..00000000
--- a/tests/refinement-tests/basic-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building basic test")
-
-set(target basic-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources basic-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(basic "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(basic PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/basic-tests/basic-tests.cpp b/tests/refinement-tests/basic-tests/basic-tests.cpp
deleted file mode 100644
index 8baeb128..00000000
--- a/tests/refinement-tests/basic-tests/basic-tests.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("accepts refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<length_r> |= quantity_t<systems::si::meter_t>{}) == quantity_t<systems::si::meter_t>{});
-  REQUIRE((mitama::accepts<mass_r> |= quantity_t<systems::si::kilogram_t>{}) == quantity_t<systems::si::kilogram_t>{});
-  REQUIRE((mitama::accepts<time_r> |= quantity_t<systems::si::second_t>{}) == quantity_t<systems::si::second_t>{});
-  REQUIRE((mitama::accepts<current_r> |= quantity_t<systems::si::ampere_t>{}) == quantity_t<systems::si::ampere_t>{});
-  REQUIRE((mitama::accepts<thermo_r> |= quantity_t<systems::si::kelvin_t>{}) == quantity_t<systems::si::kelvin_t>{});
-  REQUIRE((mitama::accepts<amount_r> |= quantity_t<systems::si::mol_t>{}) == quantity_t<systems::si::mol_t>{});
-  REQUIRE((mitama::accepts<luminous_r> |= quantity_t<systems::si::candela_t>{}) == quantity_t<systems::si::candela_t>{});
-}
-
-TEST_CASE("rejects refinement test", "[quantity][refinement]") {
-  REQUIRE(IS_INVALID_EXPR(mitama::rejects<DECLTYPE(0)> |= DECLVAL(1))(length_r, quantity_t<systems::si::meter_t>));
-  REQUIRE(IS_INVALID_EXPR(mitama::rejects<DECLTYPE(0)> |= DECLVAL(1))(mass_r, quantity_t<systems::si::kilogram_t>));
-  REQUIRE(IS_INVALID_EXPR(mitama::rejects<DECLTYPE(0)> |= DECLVAL(1))(time_r, quantity_t<systems::si::second_t>));
-  REQUIRE(IS_INVALID_EXPR(mitama::rejects<DECLTYPE(0)> |= DECLVAL(1))(current_r, quantity_t<systems::si::ampere_t>));
-  REQUIRE(IS_INVALID_EXPR(mitama::rejects<DECLTYPE(0)> |= DECLVAL(1))(thermo_r, quantity_t<systems::si::kelvin_t>));
-  REQUIRE(IS_INVALID_EXPR(mitama::rejects<DECLTYPE(0)> |= DECLVAL(1))(amount_r, quantity_t<systems::si::mol_t>));
-  REQUIRE(IS_INVALID_EXPR(mitama::rejects<DECLTYPE(0)> |= DECLVAL(1))(luminous_r, quantity_t<systems::si::candela_t>));
-}
-
diff --git a/tests/refinement-tests/capacitance-tests/CMakeLists.txt b/tests/refinement-tests/capacitance-tests/CMakeLists.txt
deleted file mode 100644
index 292fb57a..00000000
--- a/tests/refinement-tests/capacitance-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building capacitance test")
-
-set(target capacitance-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources capacitance-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(capacitance "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(capacitance PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/capacitance-tests/capacitance-tests.cpp b/tests/refinement-tests/capacitance-tests/capacitance-tests.cpp
deleted file mode 100644
index 1171e5f3..00000000
--- a/tests/refinement-tests/capacitance-tests/capacitance-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/capacitance.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("capacitance refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::capacitance_r> |= quantity_t<systems::si::capacitance_t>{}) == quantity_t<systems::si::capacitance_t>{});
-}
-
diff --git a/tests/refinement-tests/catalytic_activity-tests/CMakeLists.txt b/tests/refinement-tests/catalytic_activity-tests/CMakeLists.txt
deleted file mode 100644
index 20d195a2..00000000
--- a/tests/refinement-tests/catalytic_activity-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building catalytic_activity test")
-
-set(target catalytic_activity-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources catalytic_activity-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(catalytic_activity "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(catalytic_activity PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/catalytic_activity-tests/catalytic_activity-tests.cpp b/tests/refinement-tests/catalytic_activity-tests/catalytic_activity-tests.cpp
deleted file mode 100644
index ffe71c9c..00000000
--- a/tests/refinement-tests/catalytic_activity-tests/catalytic_activity-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/catalytic_activity.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("catalytic_activity refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::catalytic_activity_r> |= quantity_t<systems::si::catalytic_activity_t>{}) == quantity_t<systems::si::catalytic_activity_t>{});
-}
-
diff --git a/tests/refinement-tests/catalytic_efficiency-tests/CMakeLists.txt b/tests/refinement-tests/catalytic_efficiency-tests/CMakeLists.txt
deleted file mode 100644
index 2bf71337..00000000
--- a/tests/refinement-tests/catalytic_efficiency-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building catalytic_efficiency test")
-
-set(target catalytic_efficiency-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources catalytic_efficiency-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(catalytic_efficiency "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(catalytic_efficiency PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/catalytic_efficiency-tests/catalytic_efficiency-tests.cpp b/tests/refinement-tests/catalytic_efficiency-tests/catalytic_efficiency-tests.cpp
deleted file mode 100644
index d194e368..00000000
--- a/tests/refinement-tests/catalytic_efficiency-tests/catalytic_efficiency-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/catalytic_efficiency.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("catalytic_efficiency refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::catalytic_efficiency_r> |= quantity_t<systems::si::catalytic_efficiency_t>{}) == quantity_t<systems::si::catalytic_efficiency_t>{});
-}
-
diff --git a/tests/refinement-tests/compressibility-tests/CMakeLists.txt b/tests/refinement-tests/compressibility-tests/CMakeLists.txt
deleted file mode 100644
index 907818ca..00000000
--- a/tests/refinement-tests/compressibility-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building compressibility test")
-
-set(target compressibility-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources compressibility-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(compressibility "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(compressibility PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/compressibility-tests/compressibility-tests.cpp b/tests/refinement-tests/compressibility-tests/compressibility-tests.cpp
deleted file mode 100644
index 439fa1fb..00000000
--- a/tests/refinement-tests/compressibility-tests/compressibility-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/compressibility.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("compressibility refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::compressibility_r> |= quantity_t<systems::si::compressibility_t>{}) == quantity_t<systems::si::compressibility_t>{});
-}
-
diff --git a/tests/refinement-tests/conductance-tests/CMakeLists.txt b/tests/refinement-tests/conductance-tests/CMakeLists.txt
deleted file mode 100644
index 69be4ca2..00000000
--- a/tests/refinement-tests/conductance-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building conductance test")
-
-set(target conductance-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources conductance-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(conductance "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(conductance PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/conductance-tests/conductance-tests.cpp b/tests/refinement-tests/conductance-tests/conductance-tests.cpp
deleted file mode 100644
index 10078cb8..00000000
--- a/tests/refinement-tests/conductance-tests/conductance-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/conductance.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("conductance refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::conductance_r> |= quantity_t<systems::si::conductance_t>{}) == quantity_t<systems::si::conductance_t>{});
-}
-
diff --git a/tests/refinement-tests/configure.sh b/tests/refinement-tests/configure.sh
deleted file mode 100644
index df8e1ae5..00000000
--- a/tests/refinement-tests/configure.sh
+++ /dev/null
@@ -1,2 +0,0 @@
-find ../../include/dimensional/systems/si/derived_units -name '*.hpp' | xargs -I{} basename {} | sed -E 's/(.*)\.hpp/\1/' | xargs -I{} ./refinement-test-gen.sh {}
-find . -maxdepth 1 -type d | sed -E 's/(.*)/add_subdirectory(\1)/' > ./CMakeLists.txt
\ No newline at end of file
diff --git a/tests/refinement-tests/crackle-tests/CMakeLists.txt b/tests/refinement-tests/crackle-tests/CMakeLists.txt
deleted file mode 100644
index e0b1397c..00000000
--- a/tests/refinement-tests/crackle-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building crackle test")
-
-set(target crackle-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources crackle-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(crackle "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(crackle PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/crackle-tests/crackle-tests.cpp b/tests/refinement-tests/crackle-tests/crackle-tests.cpp
deleted file mode 100644
index 5e33f1e4..00000000
--- a/tests/refinement-tests/crackle-tests/crackle-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/crackle.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("crackle refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::crackle_r> |= quantity_t<systems::si::crackle_t>{}) == quantity_t<systems::si::crackle_t>{});
-}
-
diff --git a/tests/refinement-tests/curvature-tests/CMakeLists.txt b/tests/refinement-tests/curvature-tests/CMakeLists.txt
deleted file mode 100644
index 09ddb74d..00000000
--- a/tests/refinement-tests/curvature-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building curvature test")
-
-set(target curvature-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources curvature-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(curvature "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(curvature PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/curvature-tests/curvature-tests.cpp b/tests/refinement-tests/curvature-tests/curvature-tests.cpp
deleted file mode 100644
index 865c888c..00000000
--- a/tests/refinement-tests/curvature-tests/curvature-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/curvature.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("curvature refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::curvature_r> |= quantity_t<systems::si::curvature_t>{}) == quantity_t<systems::si::curvature_t>{});
-}
-
diff --git a/tests/refinement-tests/density-tests/CMakeLists.txt b/tests/refinement-tests/density-tests/CMakeLists.txt
deleted file mode 100644
index 6c6402a9..00000000
--- a/tests/refinement-tests/density-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building density test")
-
-set(target density-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources density-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(density "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(density PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/density-tests/density-tests.cpp b/tests/refinement-tests/density-tests/density-tests.cpp
deleted file mode 100644
index 83cd8a87..00000000
--- a/tests/refinement-tests/density-tests/density-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/density.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("density refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::density_r> |= quantity_t<systems::si::density_t>{}) == quantity_t<systems::si::density_t>{});
-}
-
diff --git a/tests/refinement-tests/diffusion_coefficient-tests/CMakeLists.txt b/tests/refinement-tests/diffusion_coefficient-tests/CMakeLists.txt
deleted file mode 100644
index eea102c0..00000000
--- a/tests/refinement-tests/diffusion_coefficient-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building diffusion_coefficient test")
-
-set(target diffusion_coefficient-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources diffusion_coefficient-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(diffusion_coefficient "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(diffusion_coefficient PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/diffusion_coefficient-tests/diffusion_coefficient-tests.cpp b/tests/refinement-tests/diffusion_coefficient-tests/diffusion_coefficient-tests.cpp
deleted file mode 100644
index e8257a07..00000000
--- a/tests/refinement-tests/diffusion_coefficient-tests/diffusion_coefficient-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/diffusion_coefficient.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("diffusion_coefficient refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::diffusion_coefficient_r> |= quantity_t<systems::si::diffusion_coefficient_t>{}) == quantity_t<systems::si::diffusion_coefficient_t>{});
-}
-
diff --git a/tests/refinement-tests/dynamic_viscosity-tests/CMakeLists.txt b/tests/refinement-tests/dynamic_viscosity-tests/CMakeLists.txt
deleted file mode 100644
index 1fddb42d..00000000
--- a/tests/refinement-tests/dynamic_viscosity-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building dynamic_viscosity test")
-
-set(target dynamic_viscosity-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources dynamic_viscosity-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(dynamic_viscosity "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(dynamic_viscosity PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/dynamic_viscosity-tests/dynamic_viscosity-tests.cpp b/tests/refinement-tests/dynamic_viscosity-tests/dynamic_viscosity-tests.cpp
deleted file mode 100644
index 23efb637..00000000
--- a/tests/refinement-tests/dynamic_viscosity-tests/dynamic_viscosity-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/dynamic_viscosity.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("dynamic_viscosity refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::dynamic_viscosity_r> |= quantity_t<systems::si::dynamic_viscosity_t>{}) == quantity_t<systems::si::dynamic_viscosity_t>{});
-}
-
diff --git a/tests/refinement-tests/electric_charge-tests/CMakeLists.txt b/tests/refinement-tests/electric_charge-tests/CMakeLists.txt
deleted file mode 100644
index fe2b753a..00000000
--- a/tests/refinement-tests/electric_charge-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building electric_charge test")
-
-set(target electric_charge-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources electric_charge-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(electric_charge "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(electric_charge PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/electric_charge-tests/electric_charge-tests.cpp b/tests/refinement-tests/electric_charge-tests/electric_charge-tests.cpp
deleted file mode 100644
index 0168481d..00000000
--- a/tests/refinement-tests/electric_charge-tests/electric_charge-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/electric_charge.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("electric_charge refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::electric_charge_r> |= quantity_t<systems::si::electric_charge_t>{}) == quantity_t<systems::si::electric_charge_t>{});
-}
-
diff --git a/tests/refinement-tests/electric_charge_density-tests/CMakeLists.txt b/tests/refinement-tests/electric_charge_density-tests/CMakeLists.txt
deleted file mode 100644
index 15f7fdc5..00000000
--- a/tests/refinement-tests/electric_charge_density-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building electric_charge_density test")
-
-set(target electric_charge_density-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources electric_charge_density-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(electric_charge_density "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(electric_charge_density PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/electric_charge_density-tests/electric_charge_density-tests.cpp b/tests/refinement-tests/electric_charge_density-tests/electric_charge_density-tests.cpp
deleted file mode 100644
index baeabeb2..00000000
--- a/tests/refinement-tests/electric_charge_density-tests/electric_charge_density-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/electric_charge_density.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("electric_charge_density refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::electric_charge_density_r> |= quantity_t<systems::si::electric_charge_density_t>{}) == quantity_t<systems::si::electric_charge_density_t>{});
-}
-
diff --git a/tests/refinement-tests/electric_current_density-tests/CMakeLists.txt b/tests/refinement-tests/electric_current_density-tests/CMakeLists.txt
deleted file mode 100644
index fb1fd4cf..00000000
--- a/tests/refinement-tests/electric_current_density-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building electric_current_density test")
-
-set(target electric_current_density-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources electric_current_density-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(electric_current_density "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(electric_current_density PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/electric_current_density-tests/electric_current_density-tests.cpp b/tests/refinement-tests/electric_current_density-tests/electric_current_density-tests.cpp
deleted file mode 100644
index 2eaec373..00000000
--- a/tests/refinement-tests/electric_current_density-tests/electric_current_density-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/electric_current_density.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("electric_current_density refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::electric_current_density_r> |= quantity_t<systems::si::electric_current_density_t>{}) == quantity_t<systems::si::electric_current_density_t>{});
-}
-
diff --git a/tests/refinement-tests/electric_displacement_field-tests/CMakeLists.txt b/tests/refinement-tests/electric_displacement_field-tests/CMakeLists.txt
deleted file mode 100644
index a2c1ad12..00000000
--- a/tests/refinement-tests/electric_displacement_field-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building electric_displacement_field test")
-
-set(target electric_displacement_field-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources electric_displacement_field-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(electric_displacement_field "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(electric_displacement_field PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/electric_displacement_field-tests/electric_displacement_field-tests.cpp b/tests/refinement-tests/electric_displacement_field-tests/electric_displacement_field-tests.cpp
deleted file mode 100644
index e9aa9600..00000000
--- a/tests/refinement-tests/electric_displacement_field-tests/electric_displacement_field-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/electric_displacement_field.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("electric_displacement_field refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::electric_displacement_field_r> |= quantity_t<systems::si::electric_displacement_field_t>{}) == quantity_t<systems::si::electric_displacement_field_t>{});
-}
-
diff --git a/tests/refinement-tests/electric_field_strength-tests/CMakeLists.txt b/tests/refinement-tests/electric_field_strength-tests/CMakeLists.txt
deleted file mode 100644
index 95f052f5..00000000
--- a/tests/refinement-tests/electric_field_strength-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building electric_field_strength test")
-
-set(target electric_field_strength-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources electric_field_strength-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(electric_field_strength "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(electric_field_strength PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/electric_field_strength-tests/electric_field_strength-tests.cpp b/tests/refinement-tests/electric_field_strength-tests/electric_field_strength-tests.cpp
deleted file mode 100644
index b761778b..00000000
--- a/tests/refinement-tests/electric_field_strength-tests/electric_field_strength-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/electric_field_strength.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("electric_field_strength refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::electric_field_strength_r> |= quantity_t<systems::si::electric_field_strength_t>{}) == quantity_t<systems::si::electric_field_strength_t>{});
-}
-
diff --git a/tests/refinement-tests/electric_potential-tests/CMakeLists.txt b/tests/refinement-tests/electric_potential-tests/CMakeLists.txt
deleted file mode 100644
index 84b1b70f..00000000
--- a/tests/refinement-tests/electric_potential-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building electric_potential test")
-
-set(target electric_potential-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources electric_potential-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(electric_potential "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(electric_potential PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/electric_potential-tests/electric_potential-tests.cpp b/tests/refinement-tests/electric_potential-tests/electric_potential-tests.cpp
deleted file mode 100644
index 3238eb03..00000000
--- a/tests/refinement-tests/electric_potential-tests/electric_potential-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/electric_potential.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("electric_potential refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::electric_potential_r> |= quantity_t<systems::si::electric_potential_t>{}) == quantity_t<systems::si::electric_potential_t>{});
-}
-
diff --git a/tests/refinement-tests/electrical_conductivity-tests/CMakeLists.txt b/tests/refinement-tests/electrical_conductivity-tests/CMakeLists.txt
deleted file mode 100644
index 4d2777e6..00000000
--- a/tests/refinement-tests/electrical_conductivity-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building electrical_conductivity test")
-
-set(target electrical_conductivity-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources electrical_conductivity-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(electrical_conductivity "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(electrical_conductivity PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/electrical_conductivity-tests/electrical_conductivity-tests.cpp b/tests/refinement-tests/electrical_conductivity-tests/electrical_conductivity-tests.cpp
deleted file mode 100644
index bdd18d8e..00000000
--- a/tests/refinement-tests/electrical_conductivity-tests/electrical_conductivity-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/electrical_conductivity.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("electrical_conductivity refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::electrical_conductivity_r> |= quantity_t<systems::si::electrical_conductivity_t>{}) == quantity_t<systems::si::electrical_conductivity_t>{});
-}
-
diff --git a/tests/refinement-tests/electron_mobility-tests/CMakeLists.txt b/tests/refinement-tests/electron_mobility-tests/CMakeLists.txt
deleted file mode 100644
index 6d5a3a25..00000000
--- a/tests/refinement-tests/electron_mobility-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building electron_mobility test")
-
-set(target electron_mobility-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources electron_mobility-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(electron_mobility "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(electron_mobility PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/electron_mobility-tests/electron_mobility-tests.cpp b/tests/refinement-tests/electron_mobility-tests/electron_mobility-tests.cpp
deleted file mode 100644
index be34418c..00000000
--- a/tests/refinement-tests/electron_mobility-tests/electron_mobility-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/electron_mobility.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("electron_mobility refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::electron_mobility_r> |= quantity_t<systems::si::electron_mobility_t>{}) == quantity_t<systems::si::electron_mobility_t>{});
-}
-
diff --git a/tests/refinement-tests/energy-tests/CMakeLists.txt b/tests/refinement-tests/energy-tests/CMakeLists.txt
deleted file mode 100644
index 0cc31cd5..00000000
--- a/tests/refinement-tests/energy-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building energy test")
-
-set(target energy-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources energy-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(energy "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(energy PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/energy-tests/energy-tests.cpp b/tests/refinement-tests/energy-tests/energy-tests.cpp
deleted file mode 100644
index 31602f5c..00000000
--- a/tests/refinement-tests/energy-tests/energy-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/energy.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("energy refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::energy_r> |= quantity_t<systems::si::energy_t>{}) == quantity_t<systems::si::energy_t>{});
-}
-
diff --git a/tests/refinement-tests/energy_density-tests/CMakeLists.txt b/tests/refinement-tests/energy_density-tests/CMakeLists.txt
deleted file mode 100644
index 86aa6eb9..00000000
--- a/tests/refinement-tests/energy_density-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building energy_density test")
-
-set(target energy_density-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources energy_density-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(energy_density "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(energy_density PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/energy_density-tests/energy_density-tests.cpp b/tests/refinement-tests/energy_density-tests/energy_density-tests.cpp
deleted file mode 100644
index 6326433e..00000000
--- a/tests/refinement-tests/energy_density-tests/energy_density-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/energy_density.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("energy_density refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::energy_density_r> |= quantity_t<systems::si::energy_density_t>{}) == quantity_t<systems::si::energy_density_t>{});
-}
-
diff --git a/tests/refinement-tests/energy_flux_density-tests/CMakeLists.txt b/tests/refinement-tests/energy_flux_density-tests/CMakeLists.txt
deleted file mode 100644
index ebf081dc..00000000
--- a/tests/refinement-tests/energy_flux_density-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building energy_flux_density test")
-
-set(target energy_flux_density-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources energy_flux_density-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(energy_flux_density "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(energy_flux_density PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/energy_flux_density-tests/energy_flux_density-tests.cpp b/tests/refinement-tests/energy_flux_density-tests/energy_flux_density-tests.cpp
deleted file mode 100644
index 415804d7..00000000
--- a/tests/refinement-tests/energy_flux_density-tests/energy_flux_density-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/energy_flux_density.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("energy_flux_density refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::energy_flux_density_r> |= quantity_t<systems::si::energy_flux_density_t>{}) == quantity_t<systems::si::energy_flux_density_t>{});
-}
-
diff --git a/tests/refinement-tests/entropy-tests/CMakeLists.txt b/tests/refinement-tests/entropy-tests/CMakeLists.txt
deleted file mode 100644
index c5d3f3eb..00000000
--- a/tests/refinement-tests/entropy-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building entropy test")
-
-set(target entropy-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources entropy-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(entropy "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(entropy PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/entropy-tests/entropy-tests.cpp b/tests/refinement-tests/entropy-tests/entropy-tests.cpp
deleted file mode 100644
index 6e6f981e..00000000
--- a/tests/refinement-tests/entropy-tests/entropy-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/entropy.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("entropy refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::entropy_r> |= quantity_t<systems::si::entropy_t>{}) == quantity_t<systems::si::entropy_t>{});
-}
-
diff --git a/tests/refinement-tests/equivalent_dose-tests/CMakeLists.txt b/tests/refinement-tests/equivalent_dose-tests/CMakeLists.txt
deleted file mode 100644
index dd8a809e..00000000
--- a/tests/refinement-tests/equivalent_dose-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building equivalent_dose test")
-
-set(target equivalent_dose-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources equivalent_dose-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(equivalent_dose "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(equivalent_dose PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/equivalent_dose-tests/equivalent_dose-tests.cpp b/tests/refinement-tests/equivalent_dose-tests/equivalent_dose-tests.cpp
deleted file mode 100644
index 19b16d8f..00000000
--- a/tests/refinement-tests/equivalent_dose-tests/equivalent_dose-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/equivalent_dose.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("equivalent_dose refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::equivalent_dose_r> |= quantity_t<systems::si::sievert_t>{}) == quantity_t<systems::si::sievert_t>{});
-}
-
diff --git a/tests/refinement-tests/exposure-tests/CMakeLists.txt b/tests/refinement-tests/exposure-tests/CMakeLists.txt
deleted file mode 100644
index 9ad221fb..00000000
--- a/tests/refinement-tests/exposure-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building exposure test")
-
-set(target exposure-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources exposure-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(exposure "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(exposure PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/exposure-tests/exposure-tests.cpp b/tests/refinement-tests/exposure-tests/exposure-tests.cpp
deleted file mode 100644
index 5aeb4291..00000000
--- a/tests/refinement-tests/exposure-tests/exposure-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/exposure.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("exposure refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::exposure_r> |= quantity_t<systems::si::exposure_t>{}) == quantity_t<systems::si::exposure_t>{});
-}
-
diff --git a/tests/refinement-tests/force-tests/CMakeLists.txt b/tests/refinement-tests/force-tests/CMakeLists.txt
deleted file mode 100644
index 3adaf245..00000000
--- a/tests/refinement-tests/force-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building force test")
-
-set(target force-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources force-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(force "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(force PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/force-tests/force-tests.cpp b/tests/refinement-tests/force-tests/force-tests.cpp
deleted file mode 100644
index 6e63e53d..00000000
--- a/tests/refinement-tests/force-tests/force-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/force.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("force refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::force_r> |= quantity_t<systems::si::force_t>{}) == quantity_t<systems::si::force_t>{});
-}
-
diff --git a/tests/refinement-tests/frequency-tests/CMakeLists.txt b/tests/refinement-tests/frequency-tests/CMakeLists.txt
deleted file mode 100644
index b564d01f..00000000
--- a/tests/refinement-tests/frequency-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building frequency test")
-
-set(target frequency-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources frequency-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(frequency "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(frequency PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/frequency-tests/frequency-tests.cpp b/tests/refinement-tests/frequency-tests/frequency-tests.cpp
deleted file mode 100644
index a912a7e3..00000000
--- a/tests/refinement-tests/frequency-tests/frequency-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/frequency.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("frequency refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::frequency_r> |= quantity_t<systems::si::frequency_t>{}) == quantity_t<systems::si::frequency_t>{});
-}
-
diff --git a/tests/refinement-tests/frequency_drift-tests/CMakeLists.txt b/tests/refinement-tests/frequency_drift-tests/CMakeLists.txt
deleted file mode 100644
index f0a30994..00000000
--- a/tests/refinement-tests/frequency_drift-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building frequency_drift test")
-
-set(target frequency_drift-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources frequency_drift-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(frequency_drift "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(frequency_drift PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/frequency_drift-tests/frequency_drift-tests.cpp b/tests/refinement-tests/frequency_drift-tests/frequency_drift-tests.cpp
deleted file mode 100644
index 81250b1f..00000000
--- a/tests/refinement-tests/frequency_drift-tests/frequency_drift-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/frequency_drift.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("frequency_drift refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::frequency_drift_r> |= quantity_t<systems::si::frequency_drift_t>{}) == quantity_t<systems::si::frequency_drift_t>{});
-}
-
diff --git a/tests/refinement-tests/fuel_efficiency-tests/CMakeLists.txt b/tests/refinement-tests/fuel_efficiency-tests/CMakeLists.txt
deleted file mode 100644
index c869a458..00000000
--- a/tests/refinement-tests/fuel_efficiency-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building fuel_efficiency test")
-
-set(target fuel_efficiency-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources fuel_efficiency-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(fuel_efficiency "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(fuel_efficiency PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/fuel_efficiency-tests/fuel_efficiency-tests.cpp b/tests/refinement-tests/fuel_efficiency-tests/fuel_efficiency-tests.cpp
deleted file mode 100644
index 9f23a319..00000000
--- a/tests/refinement-tests/fuel_efficiency-tests/fuel_efficiency-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/fuel_efficiency.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("fuel_efficiency refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::fuel_efficiency_r> |= quantity_t<systems::si::fuel_efficiency_t>{}) == quantity_t<systems::si::fuel_efficiency_t>{});
-}
-
diff --git a/tests/refinement-tests/heat-tests/CMakeLists.txt b/tests/refinement-tests/heat-tests/CMakeLists.txt
deleted file mode 100644
index d653f9bc..00000000
--- a/tests/refinement-tests/heat-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building heat test")
-
-set(target heat-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources heat-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(heat "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(heat PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/heat-tests/heat-tests.cpp b/tests/refinement-tests/heat-tests/heat-tests.cpp
deleted file mode 100644
index feaa0aac..00000000
--- a/tests/refinement-tests/heat-tests/heat-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/heat.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("heat refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::heat_r> |= quantity_t<systems::si::heat_t>{}) == quantity_t<systems::si::heat_t>{});
-}
-
diff --git a/tests/refinement-tests/heat_capacity-tests/CMakeLists.txt b/tests/refinement-tests/heat_capacity-tests/CMakeLists.txt
deleted file mode 100644
index 56a41ffc..00000000
--- a/tests/refinement-tests/heat_capacity-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building heat_capacity test")
-
-set(target heat_capacity-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources heat_capacity-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(heat_capacity "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(heat_capacity PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/heat_capacity-tests/heat_capacity-tests.cpp b/tests/refinement-tests/heat_capacity-tests/heat_capacity-tests.cpp
deleted file mode 100644
index 681fb948..00000000
--- a/tests/refinement-tests/heat_capacity-tests/heat_capacity-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/heat_capacity.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("heat_capacity refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::heat_capacity_r> |= quantity_t<systems::si::heat_capacity_t>{}) == quantity_t<systems::si::heat_capacity_t>{});
-}
-
diff --git a/tests/refinement-tests/heat_flux-tests/CMakeLists.txt b/tests/refinement-tests/heat_flux-tests/CMakeLists.txt
deleted file mode 100644
index 78a90698..00000000
--- a/tests/refinement-tests/heat_flux-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building heat_flux test")
-
-set(target heat_flux-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources heat_flux-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(heat_flux "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(heat_flux PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/heat_flux-tests/heat_flux-tests.cpp b/tests/refinement-tests/heat_flux-tests/heat_flux-tests.cpp
deleted file mode 100644
index f54c2395..00000000
--- a/tests/refinement-tests/heat_flux-tests/heat_flux-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/heat_flux.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("heat_flux refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::heat_flux_r> |= quantity_t<systems::si::heat_flux_t>{}) == quantity_t<systems::si::heat_flux_t>{});
-}
-
diff --git a/tests/refinement-tests/heat_flux_density-tests/CMakeLists.txt b/tests/refinement-tests/heat_flux_density-tests/CMakeLists.txt
deleted file mode 100644
index a76fe8de..00000000
--- a/tests/refinement-tests/heat_flux_density-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building heat_flux_density test")
-
-set(target heat_flux_density-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources heat_flux_density-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(heat_flux_density "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(heat_flux_density PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/heat_flux_density-tests/heat_flux_density-tests.cpp b/tests/refinement-tests/heat_flux_density-tests/heat_flux_density-tests.cpp
deleted file mode 100644
index 24a17eb5..00000000
--- a/tests/refinement-tests/heat_flux_density-tests/heat_flux_density-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/heat_flux_density.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("heat_flux_density refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::heat_flux_density_r> |= quantity_t<systems::si::heat_flux_density_t>{}) == quantity_t<systems::si::heat_flux_density_t>{});
-}
-
diff --git a/tests/refinement-tests/illuminance-tests/CMakeLists.txt b/tests/refinement-tests/illuminance-tests/CMakeLists.txt
deleted file mode 100644
index 2a5acb65..00000000
--- a/tests/refinement-tests/illuminance-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building illuminance test")
-
-set(target illuminance-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources illuminance-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(illuminance "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(illuminance PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/illuminance-tests/illuminance-tests.cpp b/tests/refinement-tests/illuminance-tests/illuminance-tests.cpp
deleted file mode 100644
index 7ba8cca6..00000000
--- a/tests/refinement-tests/illuminance-tests/illuminance-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/illuminance.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("illuminance refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::illuminance_r> |= quantity_t<systems::si::illuminance_t>{}) == quantity_t<systems::si::illuminance_t>{});
-}
-
diff --git a/tests/refinement-tests/impedance-tests/CMakeLists.txt b/tests/refinement-tests/impedance-tests/CMakeLists.txt
deleted file mode 100644
index e25028e2..00000000
--- a/tests/refinement-tests/impedance-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building impedance test")
-
-set(target impedance-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources impedance-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(impedance "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(impedance PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/impedance-tests/impedance-tests.cpp b/tests/refinement-tests/impedance-tests/impedance-tests.cpp
deleted file mode 100644
index 776c1f4f..00000000
--- a/tests/refinement-tests/impedance-tests/impedance-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/impedance.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("impedance refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::impedance_r> |= quantity_t<systems::si::impedance_t>{}) == quantity_t<systems::si::impedance_t>{});
-}
-
diff --git a/tests/refinement-tests/impulse-tests/CMakeLists.txt b/tests/refinement-tests/impulse-tests/CMakeLists.txt
deleted file mode 100644
index e8a0079c..00000000
--- a/tests/refinement-tests/impulse-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building impulse test")
-
-set(target impulse-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources impulse-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(impulse "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(impulse PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/impulse-tests/impulse-tests.cpp b/tests/refinement-tests/impulse-tests/impulse-tests.cpp
deleted file mode 100644
index 96bc53bd..00000000
--- a/tests/refinement-tests/impulse-tests/impulse-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/impulse.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("impulse refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::impulse_r> |= quantity_t<systems::si::impulse_t>{}) == quantity_t<systems::si::impulse_t>{});
-}
-
diff --git a/tests/refinement-tests/inductance-tests/CMakeLists.txt b/tests/refinement-tests/inductance-tests/CMakeLists.txt
deleted file mode 100644
index 1a1be216..00000000
--- a/tests/refinement-tests/inductance-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building inductance test")
-
-set(target inductance-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources inductance-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(inductance "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(inductance PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/inductance-tests/inductance-tests.cpp b/tests/refinement-tests/inductance-tests/inductance-tests.cpp
deleted file mode 100644
index b7359534..00000000
--- a/tests/refinement-tests/inductance-tests/inductance-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/inductance.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("inductance refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::inductance_r> |= quantity_t<systems::si::inductance_t>{}) == quantity_t<systems::si::inductance_t>{});
-}
-
diff --git a/tests/refinement-tests/irradiance-tests/CMakeLists.txt b/tests/refinement-tests/irradiance-tests/CMakeLists.txt
deleted file mode 100644
index eaf8880b..00000000
--- a/tests/refinement-tests/irradiance-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building irradiance test")
-
-set(target irradiance-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources irradiance-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(irradiance "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(irradiance PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/irradiance-tests/irradiance-tests.cpp b/tests/refinement-tests/irradiance-tests/irradiance-tests.cpp
deleted file mode 100644
index 9e179c98..00000000
--- a/tests/refinement-tests/irradiance-tests/irradiance-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/irradiance.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("irradiance refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::irradiance_r> |= quantity_t<systems::si::irradiance_t>{}) == quantity_t<systems::si::irradiance_t>{});
-}
-
diff --git a/tests/refinement-tests/jerk-tests/CMakeLists.txt b/tests/refinement-tests/jerk-tests/CMakeLists.txt
deleted file mode 100644
index bd580030..00000000
--- a/tests/refinement-tests/jerk-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building jerk test")
-
-set(target jerk-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources jerk-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(jerk "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(jerk PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/jerk-tests/jerk-tests.cpp b/tests/refinement-tests/jerk-tests/jerk-tests.cpp
deleted file mode 100644
index a80fd4e0..00000000
--- a/tests/refinement-tests/jerk-tests/jerk-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/jerk.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("jerk refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::jerk_r> |= quantity_t<systems::si::jerk_t>{}) == quantity_t<systems::si::jerk_t>{});
-}
-
diff --git a/tests/refinement-tests/kinematic_viscosity-tests/CMakeLists.txt b/tests/refinement-tests/kinematic_viscosity-tests/CMakeLists.txt
deleted file mode 100644
index cafef775..00000000
--- a/tests/refinement-tests/kinematic_viscosity-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building kinematic_viscosity test")
-
-set(target kinematic_viscosity-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources kinematic_viscosity-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(kinematic_viscosity "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(kinematic_viscosity PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/kinematic_viscosity-tests/kinematic_viscosity-tests.cpp b/tests/refinement-tests/kinematic_viscosity-tests/kinematic_viscosity-tests.cpp
deleted file mode 100644
index 85fc490b..00000000
--- a/tests/refinement-tests/kinematic_viscosity-tests/kinematic_viscosity-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/kinematic_viscosity.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("kinematic_viscosity refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::kinematic_viscosity_r> |= quantity_t<systems::si::kinematic_viscosity_t>{}) == quantity_t<systems::si::kinematic_viscosity_t>{});
-}
-
diff --git a/tests/refinement-tests/linear_charge_density-tests/CMakeLists.txt b/tests/refinement-tests/linear_charge_density-tests/CMakeLists.txt
deleted file mode 100644
index 69409ae2..00000000
--- a/tests/refinement-tests/linear_charge_density-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building linear_charge_density test")
-
-set(target linear_charge_density-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources linear_charge_density-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(linear_charge_density "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(linear_charge_density PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/linear_charge_density-tests/linear_charge_density-tests.cpp b/tests/refinement-tests/linear_charge_density-tests/linear_charge_density-tests.cpp
deleted file mode 100644
index 965eb4d9..00000000
--- a/tests/refinement-tests/linear_charge_density-tests/linear_charge_density-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/linear_charge_density.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("linear_charge_density refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::linear_charge_density_r> |= quantity_t<systems::si::linear_charge_density_t>{}) == quantity_t<systems::si::linear_charge_density_t>{});
-}
-
diff --git a/tests/refinement-tests/linear_mass_density-tests/CMakeLists.txt b/tests/refinement-tests/linear_mass_density-tests/CMakeLists.txt
deleted file mode 100644
index c21af102..00000000
--- a/tests/refinement-tests/linear_mass_density-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building linear_mass_density test")
-
-set(target linear_mass_density-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources linear_mass_density-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(linear_mass_density "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(linear_mass_density PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/linear_mass_density-tests/linear_mass_density-tests.cpp b/tests/refinement-tests/linear_mass_density-tests/linear_mass_density-tests.cpp
deleted file mode 100644
index de957219..00000000
--- a/tests/refinement-tests/linear_mass_density-tests/linear_mass_density-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/linear_mass_density.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("linear_mass_density refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::linear_mass_density_r> |= quantity_t<systems::si::linear_mass_density_t>{}) == quantity_t<systems::si::linear_mass_density_t>{});
-}
-
diff --git a/tests/refinement-tests/luminance-tests/CMakeLists.txt b/tests/refinement-tests/luminance-tests/CMakeLists.txt
deleted file mode 100644
index 6d048176..00000000
--- a/tests/refinement-tests/luminance-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building luminance test")
-
-set(target luminance-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources luminance-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(luminance "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(luminance PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/luminance-tests/luminance-tests.cpp b/tests/refinement-tests/luminance-tests/luminance-tests.cpp
deleted file mode 100644
index f24818f1..00000000
--- a/tests/refinement-tests/luminance-tests/luminance-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/luminance.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("luminance refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::luminance_r> |= quantity_t<systems::si::luminance_t>{}) == quantity_t<systems::si::luminance_t>{});
-}
-
diff --git a/tests/refinement-tests/luminous_efficacy-tests/CMakeLists.txt b/tests/refinement-tests/luminous_efficacy-tests/CMakeLists.txt
deleted file mode 100644
index db225d21..00000000
--- a/tests/refinement-tests/luminous_efficacy-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building luminous_efficacy test")
-
-set(target luminous_efficacy-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources luminous_efficacy-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(luminous_efficacy "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(luminous_efficacy PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/luminous_efficacy-tests/luminous_efficacy-tests.cpp b/tests/refinement-tests/luminous_efficacy-tests/luminous_efficacy-tests.cpp
deleted file mode 100644
index 72fb097a..00000000
--- a/tests/refinement-tests/luminous_efficacy-tests/luminous_efficacy-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/luminous_efficacy.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("luminous_efficacy refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::luminous_efficacy_r> |= quantity_t<systems::si::luminous_efficacy_t>{}) == quantity_t<systems::si::luminous_efficacy_t>{});
-}
-
diff --git a/tests/refinement-tests/luminous_energy-tests/CMakeLists.txt b/tests/refinement-tests/luminous_energy-tests/CMakeLists.txt
deleted file mode 100644
index 03bb6e62..00000000
--- a/tests/refinement-tests/luminous_energy-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building luminous_energy test")
-
-set(target luminous_energy-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources luminous_energy-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(luminous_energy "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(luminous_energy PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/luminous_energy-tests/luminous_energy-tests.cpp b/tests/refinement-tests/luminous_energy-tests/luminous_energy-tests.cpp
deleted file mode 100644
index 9f7df510..00000000
--- a/tests/refinement-tests/luminous_energy-tests/luminous_energy-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/luminous_energy.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("luminous_energy refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::luminous_energy_r> |= quantity_t<systems::si::luminous_energy_t>{}) == quantity_t<systems::si::luminous_energy_t>{});
-}
-
diff --git a/tests/refinement-tests/luminous_exposure-tests/CMakeLists.txt b/tests/refinement-tests/luminous_exposure-tests/CMakeLists.txt
deleted file mode 100644
index 1b2e689f..00000000
--- a/tests/refinement-tests/luminous_exposure-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building luminous_exposure test")
-
-set(target luminous_exposure-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources luminous_exposure-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(luminous_exposure "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(luminous_exposure PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/luminous_exposure-tests/luminous_exposure-tests.cpp b/tests/refinement-tests/luminous_exposure-tests/luminous_exposure-tests.cpp
deleted file mode 100644
index eefc4fc8..00000000
--- a/tests/refinement-tests/luminous_exposure-tests/luminous_exposure-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/luminous_exposure.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("luminous_exposure refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::luminous_exposure_r> |= quantity_t<systems::si::luminous_exposure_t>{}) == quantity_t<systems::si::luminous_exposure_t>{});
-}
-
diff --git a/tests/refinement-tests/luminous_flux-tests/CMakeLists.txt b/tests/refinement-tests/luminous_flux-tests/CMakeLists.txt
deleted file mode 100644
index f4c725ff..00000000
--- a/tests/refinement-tests/luminous_flux-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building luminous_flux test")
-
-set(target luminous_flux-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources luminous_flux-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(luminous_flux "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(luminous_flux PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/luminous_flux-tests/luminous_flux-tests.cpp b/tests/refinement-tests/luminous_flux-tests/luminous_flux-tests.cpp
deleted file mode 100644
index 36d92f36..00000000
--- a/tests/refinement-tests/luminous_flux-tests/luminous_flux-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/luminous_flux.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("luminous_flux refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::luminous_flux_r> |= quantity_t<systems::si::luminous_flux_t>{}) == quantity_t<systems::si::luminous_flux_t>{});
-}
-
diff --git a/tests/refinement-tests/magnetic_dipole_moment-tests/CMakeLists.txt b/tests/refinement-tests/magnetic_dipole_moment-tests/CMakeLists.txt
deleted file mode 100644
index deb64e06..00000000
--- a/tests/refinement-tests/magnetic_dipole_moment-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building magnetic_dipole_moment test")
-
-set(target magnetic_dipole_moment-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources magnetic_dipole_moment-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(magnetic_dipole_moment "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(magnetic_dipole_moment PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/magnetic_dipole_moment-tests/magnetic_dipole_moment-tests.cpp b/tests/refinement-tests/magnetic_dipole_moment-tests/magnetic_dipole_moment-tests.cpp
deleted file mode 100644
index 51ca0d45..00000000
--- a/tests/refinement-tests/magnetic_dipole_moment-tests/magnetic_dipole_moment-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/magnetic_dipole_moment.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("magnetic_dipole_moment refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::magnetic_dipole_moment_r> |= quantity_t<systems::si::magnetic_dipole_moment_t>{}) == quantity_t<systems::si::magnetic_dipole_moment_t>{});
-}
-
diff --git a/tests/refinement-tests/magnetic_field_strength-tests/CMakeLists.txt b/tests/refinement-tests/magnetic_field_strength-tests/CMakeLists.txt
deleted file mode 100644
index bd9aad52..00000000
--- a/tests/refinement-tests/magnetic_field_strength-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building magnetic_field_strength test")
-
-set(target magnetic_field_strength-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources magnetic_field_strength-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(magnetic_field_strength "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(magnetic_field_strength PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/magnetic_field_strength-tests/magnetic_field_strength-tests.cpp b/tests/refinement-tests/magnetic_field_strength-tests/magnetic_field_strength-tests.cpp
deleted file mode 100644
index ff11db23..00000000
--- a/tests/refinement-tests/magnetic_field_strength-tests/magnetic_field_strength-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/magnetic_field_strength.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("magnetic_field_strength refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::magnetic_field_strength_r> |= quantity_t<systems::si::magnetic_field_strength_t>{}) == quantity_t<systems::si::magnetic_field_strength_t>{});
-}
-
diff --git a/tests/refinement-tests/magnetic_flux-tests/CMakeLists.txt b/tests/refinement-tests/magnetic_flux-tests/CMakeLists.txt
deleted file mode 100644
index ed80cb3d..00000000
--- a/tests/refinement-tests/magnetic_flux-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building magnetic_flux test")
-
-set(target magnetic_flux-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources magnetic_flux-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(magnetic_flux "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(magnetic_flux PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/magnetic_flux-tests/magnetic_flux-tests.cpp b/tests/refinement-tests/magnetic_flux-tests/magnetic_flux-tests.cpp
deleted file mode 100644
index 0bcaa240..00000000
--- a/tests/refinement-tests/magnetic_flux-tests/magnetic_flux-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/magnetic_flux.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("magnetic_flux refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::magnetic_flux_r> |= quantity_t<systems::si::magnetic_flux_t>{}) == quantity_t<systems::si::magnetic_flux_t>{});
-}
-
diff --git a/tests/refinement-tests/magnetic_flux_density-tests/CMakeLists.txt b/tests/refinement-tests/magnetic_flux_density-tests/CMakeLists.txt
deleted file mode 100644
index 82d54f61..00000000
--- a/tests/refinement-tests/magnetic_flux_density-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building magnetic_flux_density test")
-
-set(target magnetic_flux_density-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources magnetic_flux_density-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(magnetic_flux_density "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(magnetic_flux_density PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/magnetic_flux_density-tests/magnetic_flux_density-tests.cpp b/tests/refinement-tests/magnetic_flux_density-tests/magnetic_flux_density-tests.cpp
deleted file mode 100644
index 73df9b8b..00000000
--- a/tests/refinement-tests/magnetic_flux_density-tests/magnetic_flux_density-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/magnetic_flux_density.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("magnetic_flux_density refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::magnetic_flux_density_r> |= quantity_t<systems::si::magnetic_flux_density_t>{}) == quantity_t<systems::si::magnetic_flux_density_t>{});
-}
-
diff --git a/tests/refinement-tests/magnetic_moment-tests/CMakeLists.txt b/tests/refinement-tests/magnetic_moment-tests/CMakeLists.txt
deleted file mode 100644
index 90356d05..00000000
--- a/tests/refinement-tests/magnetic_moment-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building magnetic_moment test")
-
-set(target magnetic_moment-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources magnetic_moment-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(magnetic_moment "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(magnetic_moment PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/magnetic_moment-tests/magnetic_moment-tests.cpp b/tests/refinement-tests/magnetic_moment-tests/magnetic_moment-tests.cpp
deleted file mode 100644
index 754d53c1..00000000
--- a/tests/refinement-tests/magnetic_moment-tests/magnetic_moment-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/magnetic_moment.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("magnetic_moment refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::magnetic_moment_r> |= quantity_t<systems::si::magnetic_moment_t>{}) == quantity_t<systems::si::magnetic_moment_t>{});
-}
-
diff --git a/tests/refinement-tests/magnetic_reluctance-tests/CMakeLists.txt b/tests/refinement-tests/magnetic_reluctance-tests/CMakeLists.txt
deleted file mode 100644
index e9595644..00000000
--- a/tests/refinement-tests/magnetic_reluctance-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building magnetic_reluctance test")
-
-set(target magnetic_reluctance-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources magnetic_reluctance-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(magnetic_reluctance "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(magnetic_reluctance PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/magnetic_reluctance-tests/magnetic_reluctance-tests.cpp b/tests/refinement-tests/magnetic_reluctance-tests/magnetic_reluctance-tests.cpp
deleted file mode 100644
index 8e7083c6..00000000
--- a/tests/refinement-tests/magnetic_reluctance-tests/magnetic_reluctance-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/magnetic_reluctance.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("magnetic_reluctance refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::magnetic_reluctance_r> |= quantity_t<systems::si::magnetic_reluctance_t>{}) == quantity_t<systems::si::magnetic_reluctance_t>{});
-}
-
diff --git a/tests/refinement-tests/magnetic_rigidity-tests/CMakeLists.txt b/tests/refinement-tests/magnetic_rigidity-tests/CMakeLists.txt
deleted file mode 100644
index 54963f06..00000000
--- a/tests/refinement-tests/magnetic_rigidity-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building magnetic_rigidity test")
-
-set(target magnetic_rigidity-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources magnetic_rigidity-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(magnetic_rigidity "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(magnetic_rigidity PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/magnetic_rigidity-tests/magnetic_rigidity-tests.cpp b/tests/refinement-tests/magnetic_rigidity-tests/magnetic_rigidity-tests.cpp
deleted file mode 100644
index 538fbeef..00000000
--- a/tests/refinement-tests/magnetic_rigidity-tests/magnetic_rigidity-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/magnetic_rigidity.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("magnetic_rigidity refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::magnetic_rigidity_r> |= quantity_t<systems::si::magnetic_rigidity_t>{}) == quantity_t<systems::si::magnetic_rigidity_t>{});
-}
-
diff --git a/tests/refinement-tests/magnetic_susceptibility-tests/CMakeLists.txt b/tests/refinement-tests/magnetic_susceptibility-tests/CMakeLists.txt
deleted file mode 100644
index ad5b9ac1..00000000
--- a/tests/refinement-tests/magnetic_susceptibility-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building magnetic_susceptibility test")
-
-set(target magnetic_susceptibility-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources magnetic_susceptibility-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(magnetic_susceptibility "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(magnetic_susceptibility PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/magnetic_susceptibility-tests/magnetic_susceptibility-tests.cpp b/tests/refinement-tests/magnetic_susceptibility-tests/magnetic_susceptibility-tests.cpp
deleted file mode 100644
index a92197fc..00000000
--- a/tests/refinement-tests/magnetic_susceptibility-tests/magnetic_susceptibility-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/magnetic_susceptibility.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("magnetic_susceptibility refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::magnetic_susceptibility_r> |= quantity_t<systems::si::magnetic_susceptibility_t>{}) == quantity_t<systems::si::magnetic_susceptibility_t>{});
-}
-
diff --git a/tests/refinement-tests/magnetic_vector_potential-tests/CMakeLists.txt b/tests/refinement-tests/magnetic_vector_potential-tests/CMakeLists.txt
deleted file mode 100644
index d473f69f..00000000
--- a/tests/refinement-tests/magnetic_vector_potential-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building magnetic_vector_potential test")
-
-set(target magnetic_vector_potential-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources magnetic_vector_potential-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(magnetic_vector_potential "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(magnetic_vector_potential PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/magnetic_vector_potential-tests/magnetic_vector_potential-tests.cpp b/tests/refinement-tests/magnetic_vector_potential-tests/magnetic_vector_potential-tests.cpp
deleted file mode 100644
index 8b58765d..00000000
--- a/tests/refinement-tests/magnetic_vector_potential-tests/magnetic_vector_potential-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/magnetic_vector_potential.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("magnetic_vector_potential refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::magnetic_vector_potential_r> |= quantity_t<systems::si::magnetic_vector_potential_t>{}) == quantity_t<systems::si::magnetic_vector_potential_t>{});
-}
-
diff --git a/tests/refinement-tests/magnetization-tests/CMakeLists.txt b/tests/refinement-tests/magnetization-tests/CMakeLists.txt
deleted file mode 100644
index 36932cd7..00000000
--- a/tests/refinement-tests/magnetization-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building magnetization test")
-
-set(target magnetization-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources magnetization-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(magnetization "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(magnetization PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/magnetization-tests/magnetization-tests.cpp b/tests/refinement-tests/magnetization-tests/magnetization-tests.cpp
deleted file mode 100644
index 23c2e71c..00000000
--- a/tests/refinement-tests/magnetization-tests/magnetization-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/magnetization.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("magnetization refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::magnetization_r> |= quantity_t<systems::si::magnetization_t>{}) == quantity_t<systems::si::magnetization_t>{});
-}
-
diff --git a/tests/refinement-tests/magnetomotive_force-tests/CMakeLists.txt b/tests/refinement-tests/magnetomotive_force-tests/CMakeLists.txt
deleted file mode 100644
index d2802825..00000000
--- a/tests/refinement-tests/magnetomotive_force-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building magnetomotive_force test")
-
-set(target magnetomotive_force-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources magnetomotive_force-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(magnetomotive_force "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(magnetomotive_force PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/magnetomotive_force-tests/magnetomotive_force-tests.cpp b/tests/refinement-tests/magnetomotive_force-tests/magnetomotive_force-tests.cpp
deleted file mode 100644
index 19530f8a..00000000
--- a/tests/refinement-tests/magnetomotive_force-tests/magnetomotive_force-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/magnetomotive_force.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("magnetomotive_force refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::magnetomotive_force_r> |= quantity_t<systems::si::magnetomotive_force_t>{}) == quantity_t<systems::si::magnetomotive_force_t>{});
-}
-
diff --git a/tests/refinement-tests/mass_flow_rate-tests/CMakeLists.txt b/tests/refinement-tests/mass_flow_rate-tests/CMakeLists.txt
deleted file mode 100644
index c212f243..00000000
--- a/tests/refinement-tests/mass_flow_rate-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building mass_flow_rate test")
-
-set(target mass_flow_rate-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources mass_flow_rate-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(mass_flow_rate "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(mass_flow_rate PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/mass_flow_rate-tests/mass_flow_rate-tests.cpp b/tests/refinement-tests/mass_flow_rate-tests/mass_flow_rate-tests.cpp
deleted file mode 100644
index 2beef53d..00000000
--- a/tests/refinement-tests/mass_flow_rate-tests/mass_flow_rate-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/mass_flow_rate.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("mass_flow_rate refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::mass_flow_rate_r> |= quantity_t<systems::si::mass_flow_rate_t>{}) == quantity_t<systems::si::mass_flow_rate_t>{});
-}
-
diff --git a/tests/refinement-tests/molality-tests/CMakeLists.txt b/tests/refinement-tests/molality-tests/CMakeLists.txt
deleted file mode 100644
index 5ce318f8..00000000
--- a/tests/refinement-tests/molality-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building molality test")
-
-set(target molality-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources molality-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(molality "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(molality PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/molality-tests/molality-tests.cpp b/tests/refinement-tests/molality-tests/molality-tests.cpp
deleted file mode 100644
index 13888044..00000000
--- a/tests/refinement-tests/molality-tests/molality-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/molality.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("molality refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::molality_r> |= quantity_t<systems::si::molality_t>{}) == quantity_t<systems::si::molality_t>{});
-}
-
diff --git a/tests/refinement-tests/molar_conductivity-tests/CMakeLists.txt b/tests/refinement-tests/molar_conductivity-tests/CMakeLists.txt
deleted file mode 100644
index d6cbdbc4..00000000
--- a/tests/refinement-tests/molar_conductivity-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building molar_conductivity test")
-
-set(target molar_conductivity-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources molar_conductivity-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(molar_conductivity "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(molar_conductivity PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/molar_conductivity-tests/molar_conductivity-tests.cpp b/tests/refinement-tests/molar_conductivity-tests/molar_conductivity-tests.cpp
deleted file mode 100644
index f316886a..00000000
--- a/tests/refinement-tests/molar_conductivity-tests/molar_conductivity-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/molar_conductivity.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("molar_conductivity refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::molar_conductivity_r> |= quantity_t<systems::si::molar_conductivity_t>{}) == quantity_t<systems::si::molar_conductivity_t>{});
-}
-
diff --git a/tests/refinement-tests/molar_energy-tests/CMakeLists.txt b/tests/refinement-tests/molar_energy-tests/CMakeLists.txt
deleted file mode 100644
index d3ef5d05..00000000
--- a/tests/refinement-tests/molar_energy-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building molar_energy test")
-
-set(target molar_energy-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources molar_energy-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(molar_energy "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(molar_energy PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/molar_energy-tests/molar_energy-tests.cpp b/tests/refinement-tests/molar_energy-tests/molar_energy-tests.cpp
deleted file mode 100644
index 89c70e24..00000000
--- a/tests/refinement-tests/molar_energy-tests/molar_energy-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/molar_energy.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("molar_energy refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::molar_energy_r> |= quantity_t<systems::si::molar_energy_t>{}) == quantity_t<systems::si::molar_energy_t>{});
-}
-
diff --git a/tests/refinement-tests/molar_entropy-tests/CMakeLists.txt b/tests/refinement-tests/molar_entropy-tests/CMakeLists.txt
deleted file mode 100644
index fe7dc192..00000000
--- a/tests/refinement-tests/molar_entropy-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building molar_entropy test")
-
-set(target molar_entropy-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources molar_entropy-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(molar_entropy "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(molar_entropy PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/molar_entropy-tests/molar_entropy-tests.cpp b/tests/refinement-tests/molar_entropy-tests/molar_entropy-tests.cpp
deleted file mode 100644
index e5f2d69f..00000000
--- a/tests/refinement-tests/molar_entropy-tests/molar_entropy-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/molar_entropy.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("molar_entropy refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::molar_entropy_r> |= quantity_t<systems::si::molar_entropy_t>{}) == quantity_t<systems::si::molar_entropy_t>{});
-}
-
diff --git a/tests/refinement-tests/molar_heat_capacity-tests/CMakeLists.txt b/tests/refinement-tests/molar_heat_capacity-tests/CMakeLists.txt
deleted file mode 100644
index 003d5093..00000000
--- a/tests/refinement-tests/molar_heat_capacity-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building molar_heat_capacity test")
-
-set(target molar_heat_capacity-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources molar_heat_capacity-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(molar_heat_capacity "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(molar_heat_capacity PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/molar_heat_capacity-tests/molar_heat_capacity-tests.cpp b/tests/refinement-tests/molar_heat_capacity-tests/molar_heat_capacity-tests.cpp
deleted file mode 100644
index 38f0ef40..00000000
--- a/tests/refinement-tests/molar_heat_capacity-tests/molar_heat_capacity-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/molar_heat_capacity.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("molar_heat_capacity refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::molar_heat_capacity_r> |= quantity_t<systems::si::molar_heat_capacity_t>{}) == quantity_t<systems::si::molar_heat_capacity_t>{});
-}
-
diff --git a/tests/refinement-tests/molar_mass-tests/CMakeLists.txt b/tests/refinement-tests/molar_mass-tests/CMakeLists.txt
deleted file mode 100644
index eb802b52..00000000
--- a/tests/refinement-tests/molar_mass-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building molar_mass test")
-
-set(target molar_mass-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources molar_mass-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(molar_mass "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(molar_mass PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/molar_mass-tests/molar_mass-tests.cpp b/tests/refinement-tests/molar_mass-tests/molar_mass-tests.cpp
deleted file mode 100644
index 3c463f30..00000000
--- a/tests/refinement-tests/molar_mass-tests/molar_mass-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/molar_mass.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("molar_mass refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::molar_mass_r> |= quantity_t<systems::si::molar_mass_t>{}) == quantity_t<systems::si::molar_mass_t>{});
-}
-
diff --git a/tests/refinement-tests/molar_volume-tests/CMakeLists.txt b/tests/refinement-tests/molar_volume-tests/CMakeLists.txt
deleted file mode 100644
index 07f626e0..00000000
--- a/tests/refinement-tests/molar_volume-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building molar_volume test")
-
-set(target molar_volume-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources molar_volume-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(molar_volume "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(molar_volume PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/molar_volume-tests/molar_volume-tests.cpp b/tests/refinement-tests/molar_volume-tests/molar_volume-tests.cpp
deleted file mode 100644
index 4191a917..00000000
--- a/tests/refinement-tests/molar_volume-tests/molar_volume-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/molar_volume.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("molar_volume refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::molar_volume_r> |= quantity_t<systems::si::molar_volume_t>{}) == quantity_t<systems::si::molar_volume_t>{});
-}
-
diff --git a/tests/refinement-tests/molarity-tests/CMakeLists.txt b/tests/refinement-tests/molarity-tests/CMakeLists.txt
deleted file mode 100644
index ffe7ba24..00000000
--- a/tests/refinement-tests/molarity-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building molarity test")
-
-set(target molarity-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources molarity-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(molarity "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(molarity PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/molarity-tests/molarity-tests.cpp b/tests/refinement-tests/molarity-tests/molarity-tests.cpp
deleted file mode 100644
index ccc0fca0..00000000
--- a/tests/refinement-tests/molarity-tests/molarity-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/molarity.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("molarity refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::molarity_r> |= quantity_t<systems::si::molarity_t>{}) == quantity_t<systems::si::molarity_t>{});
-}
-
diff --git a/tests/refinement-tests/moment_of_inertia-tests/CMakeLists.txt b/tests/refinement-tests/moment_of_inertia-tests/CMakeLists.txt
deleted file mode 100644
index 2d7de834..00000000
--- a/tests/refinement-tests/moment_of_inertia-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building moment_of_inertia test")
-
-set(target moment_of_inertia-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources moment_of_inertia-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(moment_of_inertia "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(moment_of_inertia PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/moment_of_inertia-tests/moment_of_inertia-tests.cpp b/tests/refinement-tests/moment_of_inertia-tests/moment_of_inertia-tests.cpp
deleted file mode 100644
index a6c5b268..00000000
--- a/tests/refinement-tests/moment_of_inertia-tests/moment_of_inertia-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/moment_of_inertia.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("moment_of_inertia refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::moment_of_inertia_r> |= quantity_t<systems::si::moment_of_inertia_t>{}) == quantity_t<systems::si::moment_of_inertia_t>{});
-}
-
diff --git a/tests/refinement-tests/momentum-tests/CMakeLists.txt b/tests/refinement-tests/momentum-tests/CMakeLists.txt
deleted file mode 100644
index 1eff18b7..00000000
--- a/tests/refinement-tests/momentum-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building momentum test")
-
-set(target momentum-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources momentum-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(momentum "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(momentum PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/momentum-tests/momentum-tests.cpp b/tests/refinement-tests/momentum-tests/momentum-tests.cpp
deleted file mode 100644
index c82dac85..00000000
--- a/tests/refinement-tests/momentum-tests/momentum-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/momentum.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("momentum refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::momentum_r> |= quantity_t<systems::si::momentum_t>{}) == quantity_t<systems::si::momentum_t>{});
-}
-
diff --git a/tests/refinement-tests/optical_power-tests/CMakeLists.txt b/tests/refinement-tests/optical_power-tests/CMakeLists.txt
deleted file mode 100644
index 03b7d230..00000000
--- a/tests/refinement-tests/optical_power-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building optical_power test")
-
-set(target optical_power-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources optical_power-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(optical_power "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(optical_power PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/optical_power-tests/optical_power-tests.cpp b/tests/refinement-tests/optical_power-tests/optical_power-tests.cpp
deleted file mode 100644
index 671f2a30..00000000
--- a/tests/refinement-tests/optical_power-tests/optical_power-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/optical_power.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("optical_power refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::optical_power_r> |= quantity_t<systems::si::optical_power_t>{}) == quantity_t<systems::si::optical_power_t>{});
-}
-
diff --git a/tests/refinement-tests/permeability-tests/CMakeLists.txt b/tests/refinement-tests/permeability-tests/CMakeLists.txt
deleted file mode 100644
index 20f3606c..00000000
--- a/tests/refinement-tests/permeability-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building permeability test")
-
-set(target permeability-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources permeability-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(permeability "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(permeability PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/permeability-tests/permeability-tests.cpp b/tests/refinement-tests/permeability-tests/permeability-tests.cpp
deleted file mode 100644
index e29c1491..00000000
--- a/tests/refinement-tests/permeability-tests/permeability-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/permeability.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("permeability refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::permeability_r> |= quantity_t<systems::si::permeability_t>{}) == quantity_t<systems::si::permeability_t>{});
-}
-
diff --git a/tests/refinement-tests/permittivity-tests/CMakeLists.txt b/tests/refinement-tests/permittivity-tests/CMakeLists.txt
deleted file mode 100644
index d1115c92..00000000
--- a/tests/refinement-tests/permittivity-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building permittivity test")
-
-set(target permittivity-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources permittivity-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(permittivity "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(permittivity PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/permittivity-tests/permittivity-tests.cpp b/tests/refinement-tests/permittivity-tests/permittivity-tests.cpp
deleted file mode 100644
index f2d305b8..00000000
--- a/tests/refinement-tests/permittivity-tests/permittivity-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/permittivity.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("permittivity refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::permittivity_r> |= quantity_t<systems::si::permittivity_t>{}) == quantity_t<systems::si::permittivity_t>{});
-}
-
diff --git a/tests/refinement-tests/polarization_density-tests/CMakeLists.txt b/tests/refinement-tests/polarization_density-tests/CMakeLists.txt
deleted file mode 100644
index 65d38a4a..00000000
--- a/tests/refinement-tests/polarization_density-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building polarization_density test")
-
-set(target polarization_density-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources polarization_density-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(polarization_density "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(polarization_density PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/polarization_density-tests/polarization_density-tests.cpp b/tests/refinement-tests/polarization_density-tests/polarization_density-tests.cpp
deleted file mode 100644
index b6708b1a..00000000
--- a/tests/refinement-tests/polarization_density-tests/polarization_density-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/polarization_density.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("polarization_density refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::polarization_density_r> |= quantity_t<systems::si::polarization_density_t>{}) == quantity_t<systems::si::polarization_density_t>{});
-}
-
diff --git a/tests/refinement-tests/pop-tests/CMakeLists.txt b/tests/refinement-tests/pop-tests/CMakeLists.txt
deleted file mode 100644
index f0924b54..00000000
--- a/tests/refinement-tests/pop-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building pop test")
-
-set(target pop-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources pop-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(pop "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(pop PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/pop-tests/pop-tests.cpp b/tests/refinement-tests/pop-tests/pop-tests.cpp
deleted file mode 100644
index 1c3469de..00000000
--- a/tests/refinement-tests/pop-tests/pop-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/pop.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("pop refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::pop_r> |= quantity_t<systems::si::pop_t>{}) == quantity_t<systems::si::pop_t>{});
-}
-
diff --git a/tests/refinement-tests/power-tests/CMakeLists.txt b/tests/refinement-tests/power-tests/CMakeLists.txt
deleted file mode 100644
index 0ff0aa4a..00000000
--- a/tests/refinement-tests/power-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building power test")
-
-set(target power-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources power-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(power "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(power PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/power-tests/power-tests.cpp b/tests/refinement-tests/power-tests/power-tests.cpp
deleted file mode 100644
index 316ef48d..00000000
--- a/tests/refinement-tests/power-tests/power-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/power.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("power refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::power_r> |= quantity_t<systems::si::power_t>{}) == quantity_t<systems::si::power_t>{});
-}
-
diff --git a/tests/refinement-tests/power_density-tests/CMakeLists.txt b/tests/refinement-tests/power_density-tests/CMakeLists.txt
deleted file mode 100644
index c509c78e..00000000
--- a/tests/refinement-tests/power_density-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building power_density test")
-
-set(target power_density-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources power_density-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(power_density "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(power_density PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/power_density-tests/power_density-tests.cpp b/tests/refinement-tests/power_density-tests/power_density-tests.cpp
deleted file mode 100644
index 428e6d07..00000000
--- a/tests/refinement-tests/power_density-tests/power_density-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/power_density.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("power_density refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::power_density_r> |= quantity_t<systems::si::power_density_t>{}) == quantity_t<systems::si::power_density_t>{});
-}
-
diff --git a/tests/refinement-tests/pressure-tests/CMakeLists.txt b/tests/refinement-tests/pressure-tests/CMakeLists.txt
deleted file mode 100644
index 8089dcc7..00000000
--- a/tests/refinement-tests/pressure-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building pressure test")
-
-set(target pressure-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources pressure-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(pressure "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(pressure PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/pressure-tests/pressure-tests.cpp b/tests/refinement-tests/pressure-tests/pressure-tests.cpp
deleted file mode 100644
index 11f2632a..00000000
--- a/tests/refinement-tests/pressure-tests/pressure-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/pressure.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("pressure refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::pressure_r> |= quantity_t<systems::si::pressure_t>{}) == quantity_t<systems::si::pressure_t>{});
-}
-
diff --git a/tests/refinement-tests/radiance-tests/CMakeLists.txt b/tests/refinement-tests/radiance-tests/CMakeLists.txt
deleted file mode 100644
index 2ecdcfab..00000000
--- a/tests/refinement-tests/radiance-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building radiance test")
-
-set(target radiance-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources radiance-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(radiance "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(radiance PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/radiance-tests/radiance-tests.cpp b/tests/refinement-tests/radiance-tests/radiance-tests.cpp
deleted file mode 100644
index 6f39d095..00000000
--- a/tests/refinement-tests/radiance-tests/radiance-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/radiance.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("radiance refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::radiance_r> |= quantity_t<systems::si::radiance_t>{}) == quantity_t<systems::si::radiance_t>{});
-}
-
diff --git a/tests/refinement-tests/radiant_exposure-tests/CMakeLists.txt b/tests/refinement-tests/radiant_exposure-tests/CMakeLists.txt
deleted file mode 100644
index d57ee163..00000000
--- a/tests/refinement-tests/radiant_exposure-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building radiant_exposure test")
-
-set(target radiant_exposure-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources radiant_exposure-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(radiant_exposure "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(radiant_exposure PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/radiant_exposure-tests/radiant_exposure-tests.cpp b/tests/refinement-tests/radiant_exposure-tests/radiant_exposure-tests.cpp
deleted file mode 100644
index a6ce78e2..00000000
--- a/tests/refinement-tests/radiant_exposure-tests/radiant_exposure-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/radiant_exposure.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("radiant_exposure refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::radiant_exposure_r> |= quantity_t<systems::si::radiant_exposure_t>{}) == quantity_t<systems::si::radiant_exposure_t>{});
-}
-
diff --git a/tests/refinement-tests/radiant_flux-tests/CMakeLists.txt b/tests/refinement-tests/radiant_flux-tests/CMakeLists.txt
deleted file mode 100644
index 48e19bb8..00000000
--- a/tests/refinement-tests/radiant_flux-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building radiant_flux test")
-
-set(target radiant_flux-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources radiant_flux-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(radiant_flux "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(radiant_flux PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/radiant_flux-tests/radiant_flux-tests.cpp b/tests/refinement-tests/radiant_flux-tests/radiant_flux-tests.cpp
deleted file mode 100644
index e38fb288..00000000
--- a/tests/refinement-tests/radiant_flux-tests/radiant_flux-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/radiant_flux.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("radiant_flux refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::radiant_flux_r> |= quantity_t<systems::si::radiant_flux_t>{}) == quantity_t<systems::si::radiant_flux_t>{});
-}
-
diff --git a/tests/refinement-tests/radiant_intensity-tests/CMakeLists.txt b/tests/refinement-tests/radiant_intensity-tests/CMakeLists.txt
deleted file mode 100644
index 26adf70d..00000000
--- a/tests/refinement-tests/radiant_intensity-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building radiant_intensity test")
-
-set(target radiant_intensity-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources radiant_intensity-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(radiant_intensity "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(radiant_intensity PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/radiant_intensity-tests/radiant_intensity-tests.cpp b/tests/refinement-tests/radiant_intensity-tests/radiant_intensity-tests.cpp
deleted file mode 100644
index 4fe72669..00000000
--- a/tests/refinement-tests/radiant_intensity-tests/radiant_intensity-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/radiant_intensity.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("radiant_intensity refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::radiant_intensity_r> |= quantity_t<systems::si::radiant_intensity_t>{}) == quantity_t<systems::si::radiant_intensity_t>{});
-}
-
diff --git a/tests/refinement-tests/radioactivity-tests/CMakeLists.txt b/tests/refinement-tests/radioactivity-tests/CMakeLists.txt
deleted file mode 100644
index f72dabf8..00000000
--- a/tests/refinement-tests/radioactivity-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building radioactivity test")
-
-set(target radioactivity-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources radioactivity-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(radioactivity "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(radioactivity PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/radioactivity-tests/radioactivity-tests.cpp b/tests/refinement-tests/radioactivity-tests/radioactivity-tests.cpp
deleted file mode 100644
index 48ad29e2..00000000
--- a/tests/refinement-tests/radioactivity-tests/radioactivity-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/radioactivity.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("radioactivity refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::radioactivity_r> |= quantity_t<systems::si::radioactivity_t>{}) == quantity_t<systems::si::radioactivity_t>{});
-}
-
diff --git a/tests/refinement-tests/reactance-tests/CMakeLists.txt b/tests/refinement-tests/reactance-tests/CMakeLists.txt
deleted file mode 100644
index 85ff01a4..00000000
--- a/tests/refinement-tests/reactance-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building reactance test")
-
-set(target reactance-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources reactance-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(reactance "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(reactance PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/reactance-tests/reactance-tests.cpp b/tests/refinement-tests/reactance-tests/reactance-tests.cpp
deleted file mode 100644
index 07ee8136..00000000
--- a/tests/refinement-tests/reactance-tests/reactance-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/reactance.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("reactance refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::reactance_r> |= quantity_t<systems::si::reactance_t>{}) == quantity_t<systems::si::reactance_t>{});
-}
-
diff --git a/tests/refinement-tests/refinement-test-gen.sh b/tests/refinement-tests/refinement-test-gen.sh
deleted file mode 100755
index 1c57a316..00000000
--- a/tests/refinement-tests/refinement-test-gen.sh
+++ /dev/null
@@ -1,32 +0,0 @@
-#!/bin/bash
-if [ ! -e $1-tests ]; then
-    mkdir $1-tests
-fi
-cat <<EOS > $1-tests/$1-tests.cpp
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/$1.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("$1 refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::$1_r> |= quantity_t<systems::si::$1_t>{}) == quantity_t<systems::si::$1_t>{});
-}
-
-EOS
-cat <<EOS > $1-tests/CMakeLists.txt
-message(STATUS "Building $1 test")
-
-set(target $1-refinement-test)
-message(STATUS "Building library \${target}")
-
-set(sources $1-tests.cpp)
-
-add_executable(\${target} \${sources})
-add_test($1 "\${EXECUTABLE_OUTPUT_PATH}/\${target}")
-set_tests_properties($1 PROPERTIES LABELS "refinement")
-EOS
diff --git a/tests/refinement-tests/resistance-tests/CMakeLists.txt b/tests/refinement-tests/resistance-tests/CMakeLists.txt
deleted file mode 100644
index 38280c85..00000000
--- a/tests/refinement-tests/resistance-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building resistance test")
-
-set(target resistance-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources resistance-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(resistance "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(resistance PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/resistance-tests/resistance-tests.cpp b/tests/refinement-tests/resistance-tests/resistance-tests.cpp
deleted file mode 100644
index 558042fd..00000000
--- a/tests/refinement-tests/resistance-tests/resistance-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/resistance.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("resistance refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::resistance_r> |= quantity_t<systems::si::resistance_t>{}) == quantity_t<systems::si::resistance_t>{});
-}
-
diff --git a/tests/refinement-tests/resistivity-tests/CMakeLists.txt b/tests/refinement-tests/resistivity-tests/CMakeLists.txt
deleted file mode 100644
index 27679a5e..00000000
--- a/tests/refinement-tests/resistivity-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building resistivity test")
-
-set(target resistivity-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources resistivity-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(resistivity "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(resistivity PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/resistivity-tests/resistivity-tests.cpp b/tests/refinement-tests/resistivity-tests/resistivity-tests.cpp
deleted file mode 100644
index 21c49d51..00000000
--- a/tests/refinement-tests/resistivity-tests/resistivity-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/resistivity.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("resistivity refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::resistivity_r> |= quantity_t<systems::si::resistivity_t>{}) == quantity_t<systems::si::resistivity_t>{});
-}
-
diff --git a/tests/refinement-tests/snap-tests/CMakeLists.txt b/tests/refinement-tests/snap-tests/CMakeLists.txt
deleted file mode 100644
index 6e9eaa6a..00000000
--- a/tests/refinement-tests/snap-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building snap test")
-
-set(target snap-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources snap-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(snap "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(snap PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/snap-tests/snap-tests.cpp b/tests/refinement-tests/snap-tests/snap-tests.cpp
deleted file mode 100644
index 3179e65f..00000000
--- a/tests/refinement-tests/snap-tests/snap-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/snap.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("snap refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::snap_r> |= quantity_t<systems::si::snap_t>{}) == quantity_t<systems::si::snap_t>{});
-}
-
diff --git a/tests/refinement-tests/solid_angle-tests/CMakeLists.txt b/tests/refinement-tests/solid_angle-tests/CMakeLists.txt
deleted file mode 100644
index bf8c774e..00000000
--- a/tests/refinement-tests/solid_angle-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building solid_angle test")
-
-set(target solid_angle-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources solid_angle-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(solid_angle "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(solid_angle PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/solid_angle-tests/solid_angle-tests.cpp b/tests/refinement-tests/solid_angle-tests/solid_angle-tests.cpp
deleted file mode 100644
index 2041c352..00000000
--- a/tests/refinement-tests/solid_angle-tests/solid_angle-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/solid_angle.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("solid_angle refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::steradian_r> |= quantity_t<systems::si::steradian_t>{}) == quantity_t<systems::si::steradian_t>{});
-}
-
diff --git a/tests/refinement-tests/spatial_frequency-tests/CMakeLists.txt b/tests/refinement-tests/spatial_frequency-tests/CMakeLists.txt
deleted file mode 100644
index ae489b8d..00000000
--- a/tests/refinement-tests/spatial_frequency-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building spatial_frequency test")
-
-set(target spatial_frequency-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources spatial_frequency-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(spatial_frequency "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(spatial_frequency PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/spatial_frequency-tests/spatial_frequency-tests.cpp b/tests/refinement-tests/spatial_frequency-tests/spatial_frequency-tests.cpp
deleted file mode 100644
index ae0a4acd..00000000
--- a/tests/refinement-tests/spatial_frequency-tests/spatial_frequency-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/spatial_frequency.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("spatial_frequency refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::spatial_frequency_r> |= quantity_t<systems::si::spatial_frequency_t>{}) == quantity_t<systems::si::spatial_frequency_t>{});
-}
-
diff --git a/tests/refinement-tests/specific_angular_momentum-tests/CMakeLists.txt b/tests/refinement-tests/specific_angular_momentum-tests/CMakeLists.txt
deleted file mode 100644
index 4c1d4814..00000000
--- a/tests/refinement-tests/specific_angular_momentum-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building specific_angular_momentum test")
-
-set(target specific_angular_momentum-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources specific_angular_momentum-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(specific_angular_momentum "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(specific_angular_momentum PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/specific_angular_momentum-tests/specific_angular_momentum-tests.cpp b/tests/refinement-tests/specific_angular_momentum-tests/specific_angular_momentum-tests.cpp
deleted file mode 100644
index 6ed79220..00000000
--- a/tests/refinement-tests/specific_angular_momentum-tests/specific_angular_momentum-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/specific_angular_momentum.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("specific_angular_momentum refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::specific_angular_momentum_r> |= quantity_t<systems::si::specific_angular_momentum_t>{}) == quantity_t<systems::si::specific_angular_momentum_t>{});
-}
-
diff --git a/tests/refinement-tests/specific_energy-tests/CMakeLists.txt b/tests/refinement-tests/specific_energy-tests/CMakeLists.txt
deleted file mode 100644
index 5e893496..00000000
--- a/tests/refinement-tests/specific_energy-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building specific_energy test")
-
-set(target specific_energy-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources specific_energy-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(specific_energy "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(specific_energy PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/specific_energy-tests/specific_energy-tests.cpp b/tests/refinement-tests/specific_energy-tests/specific_energy-tests.cpp
deleted file mode 100644
index d3047a61..00000000
--- a/tests/refinement-tests/specific_energy-tests/specific_energy-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/specific_energy.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("specific_energy refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::specific_energy_r> |= quantity_t<systems::si::specific_energy_t>{}) == quantity_t<systems::si::specific_energy_t>{});
-}
-
diff --git a/tests/refinement-tests/specific_entropy-tests/CMakeLists.txt b/tests/refinement-tests/specific_entropy-tests/CMakeLists.txt
deleted file mode 100644
index 47dda775..00000000
--- a/tests/refinement-tests/specific_entropy-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building specific_entropy test")
-
-set(target specific_entropy-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources specific_entropy-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(specific_entropy "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(specific_entropy PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/specific_entropy-tests/specific_entropy-tests.cpp b/tests/refinement-tests/specific_entropy-tests/specific_entropy-tests.cpp
deleted file mode 100644
index e0f6329d..00000000
--- a/tests/refinement-tests/specific_entropy-tests/specific_entropy-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/specific_entropy.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("specific_entropy refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::specific_entropy_r> |= quantity_t<systems::si::specific_entropy_t>{}) == quantity_t<systems::si::specific_entropy_t>{});
-}
-
diff --git a/tests/refinement-tests/specific_heat_capacity-tests/CMakeLists.txt b/tests/refinement-tests/specific_heat_capacity-tests/CMakeLists.txt
deleted file mode 100644
index 49d592ae..00000000
--- a/tests/refinement-tests/specific_heat_capacity-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building specific_heat_capacity test")
-
-set(target specific_heat_capacity-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources specific_heat_capacity-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(specific_heat_capacity "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(specific_heat_capacity PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/specific_heat_capacity-tests/specific_heat_capacity-tests.cpp b/tests/refinement-tests/specific_heat_capacity-tests/specific_heat_capacity-tests.cpp
deleted file mode 100644
index b7971144..00000000
--- a/tests/refinement-tests/specific_heat_capacity-tests/specific_heat_capacity-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/specific_heat_capacity.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("specific_heat_capacity refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::specific_heat_capacity_r> |= quantity_t<systems::si::specific_heat_capacity_t>{}) == quantity_t<systems::si::specific_heat_capacity_t>{});
-}
-
diff --git a/tests/refinement-tests/specific_volume-tests/CMakeLists.txt b/tests/refinement-tests/specific_volume-tests/CMakeLists.txt
deleted file mode 100644
index b761e4c0..00000000
--- a/tests/refinement-tests/specific_volume-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building specific_volume test")
-
-set(target specific_volume-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources specific_volume-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(specific_volume "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(specific_volume PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/specific_volume-tests/specific_volume-tests.cpp b/tests/refinement-tests/specific_volume-tests/specific_volume-tests.cpp
deleted file mode 100644
index be3522de..00000000
--- a/tests/refinement-tests/specific_volume-tests/specific_volume-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/specific_volume.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("specific_volume refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::specific_volume_r> |= quantity_t<systems::si::specific_volume_t>{}) == quantity_t<systems::si::specific_volume_t>{});
-}
-
diff --git a/tests/refinement-tests/spectral_intensity-tests/CMakeLists.txt b/tests/refinement-tests/spectral_intensity-tests/CMakeLists.txt
deleted file mode 100644
index 79feedf9..00000000
--- a/tests/refinement-tests/spectral_intensity-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building spectral_intensity test")
-
-set(target spectral_intensity-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources spectral_intensity-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(spectral_intensity "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(spectral_intensity PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/spectral_intensity-tests/spectral_intensity-tests.cpp b/tests/refinement-tests/spectral_intensity-tests/spectral_intensity-tests.cpp
deleted file mode 100644
index 0ba7be50..00000000
--- a/tests/refinement-tests/spectral_intensity-tests/spectral_intensity-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/spectral_intensity.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("spectral_intensity refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::spectral_intensity_r> |= quantity_t<systems::si::spectral_intensity_t>{}) == quantity_t<systems::si::spectral_intensity_t>{});
-}
-
diff --git a/tests/refinement-tests/spectral_irradiance-tests/CMakeLists.txt b/tests/refinement-tests/spectral_irradiance-tests/CMakeLists.txt
deleted file mode 100644
index b32c3bed..00000000
--- a/tests/refinement-tests/spectral_irradiance-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building spectral_irradiance test")
-
-set(target spectral_irradiance-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources spectral_irradiance-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(spectral_irradiance "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(spectral_irradiance PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/spectral_irradiance-tests/spectral_irradiance-tests.cpp b/tests/refinement-tests/spectral_irradiance-tests/spectral_irradiance-tests.cpp
deleted file mode 100644
index dfc4e83d..00000000
--- a/tests/refinement-tests/spectral_irradiance-tests/spectral_irradiance-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/spectral_irradiance.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("spectral_irradiance refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::spectral_irradiance_r> |= quantity_t<systems::si::spectral_irradiance_t>{}) == quantity_t<systems::si::spectral_irradiance_t>{});
-}
-
diff --git a/tests/refinement-tests/spectral_power-tests/CMakeLists.txt b/tests/refinement-tests/spectral_power-tests/CMakeLists.txt
deleted file mode 100644
index 61688f9e..00000000
--- a/tests/refinement-tests/spectral_power-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building spectral_power test")
-
-set(target spectral_power-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources spectral_power-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(spectral_power "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(spectral_power PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/spectral_power-tests/spectral_power-tests.cpp b/tests/refinement-tests/spectral_power-tests/spectral_power-tests.cpp
deleted file mode 100644
index e2a34a58..00000000
--- a/tests/refinement-tests/spectral_power-tests/spectral_power-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/spectral_power.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("spectral_power refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::spectral_power_r> |= quantity_t<systems::si::spectral_power_t>{}) == quantity_t<systems::si::spectral_power_t>{});
-}
-
diff --git a/tests/refinement-tests/spectral_radiance-tests/CMakeLists.txt b/tests/refinement-tests/spectral_radiance-tests/CMakeLists.txt
deleted file mode 100644
index ee4fc6d0..00000000
--- a/tests/refinement-tests/spectral_radiance-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building spectral_radiance test")
-
-set(target spectral_radiance-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources spectral_radiance-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(spectral_radiance "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(spectral_radiance PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/spectral_radiance-tests/spectral_radiance-tests.cpp b/tests/refinement-tests/spectral_radiance-tests/spectral_radiance-tests.cpp
deleted file mode 100644
index cf48a502..00000000
--- a/tests/refinement-tests/spectral_radiance-tests/spectral_radiance-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/spectral_radiance.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("spectral_radiance refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::spectral_radiance_r> |= quantity_t<systems::si::spectral_radiance_t>{}) == quantity_t<systems::si::spectral_radiance_t>{});
-}
-
diff --git a/tests/refinement-tests/stiffness-tests/CMakeLists.txt b/tests/refinement-tests/stiffness-tests/CMakeLists.txt
deleted file mode 100644
index 642db861..00000000
--- a/tests/refinement-tests/stiffness-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building stiffness test")
-
-set(target stiffness-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources stiffness-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(stiffness "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(stiffness PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/stiffness-tests/stiffness-tests.cpp b/tests/refinement-tests/stiffness-tests/stiffness-tests.cpp
deleted file mode 100644
index 27dd0b99..00000000
--- a/tests/refinement-tests/stiffness-tests/stiffness-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/stiffness.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("stiffness refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::stiffness_r> |= quantity_t<systems::si::stiffness_t>{}) == quantity_t<systems::si::stiffness_t>{});
-}
-
diff --git a/tests/refinement-tests/surface_tension-tests/CMakeLists.txt b/tests/refinement-tests/surface_tension-tests/CMakeLists.txt
deleted file mode 100644
index b88f7c15..00000000
--- a/tests/refinement-tests/surface_tension-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building surface_tension test")
-
-set(target surface_tension-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources surface_tension-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(surface_tension "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(surface_tension PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/surface_tension-tests/surface_tension-tests.cpp b/tests/refinement-tests/surface_tension-tests/surface_tension-tests.cpp
deleted file mode 100644
index 0cdce618..00000000
--- a/tests/refinement-tests/surface_tension-tests/surface_tension-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/surface_tension.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("surface_tension refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::surface_tension_r> |= quantity_t<systems::si::surface_tension_t>{}) == quantity_t<systems::si::surface_tension_t>{});
-}
-
diff --git a/tests/refinement-tests/temperature_gradient-tests/CMakeLists.txt b/tests/refinement-tests/temperature_gradient-tests/CMakeLists.txt
deleted file mode 100644
index 1fad78a6..00000000
--- a/tests/refinement-tests/temperature_gradient-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building temperature_gradient test")
-
-set(target temperature_gradient-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources temperature_gradient-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(temperature_gradient "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(temperature_gradient PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/temperature_gradient-tests/temperature_gradient-tests.cpp b/tests/refinement-tests/temperature_gradient-tests/temperature_gradient-tests.cpp
deleted file mode 100644
index 043c9bd6..00000000
--- a/tests/refinement-tests/temperature_gradient-tests/temperature_gradient-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/temperature_gradient.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("temperature_gradient refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::temperature_gradient_r> |= quantity_t<systems::si::temperature_gradient_t>{}) == quantity_t<systems::si::temperature_gradient_t>{});
-}
-
diff --git a/tests/refinement-tests/thermal_conductivity-tests/CMakeLists.txt b/tests/refinement-tests/thermal_conductivity-tests/CMakeLists.txt
deleted file mode 100644
index dc7fb442..00000000
--- a/tests/refinement-tests/thermal_conductivity-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building thermal_conductivity test")
-
-set(target thermal_conductivity-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources thermal_conductivity-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(thermal_conductivity "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(thermal_conductivity PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/thermal_conductivity-tests/thermal_conductivity-tests.cpp b/tests/refinement-tests/thermal_conductivity-tests/thermal_conductivity-tests.cpp
deleted file mode 100644
index ed97dd22..00000000
--- a/tests/refinement-tests/thermal_conductivity-tests/thermal_conductivity-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/thermal_conductivity.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("thermal_conductivity refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::thermal_conductivity_r> |= quantity_t<systems::si::thermal_conductivity_t>{}) == quantity_t<systems::si::thermal_conductivity_t>{});
-}
-
diff --git a/tests/refinement-tests/thermal_diffusivity-tests/CMakeLists.txt b/tests/refinement-tests/thermal_diffusivity-tests/CMakeLists.txt
deleted file mode 100644
index 308c3eba..00000000
--- a/tests/refinement-tests/thermal_diffusivity-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building thermal_diffusivity test")
-
-set(target thermal_diffusivity-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources thermal_diffusivity-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(thermal_diffusivity "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(thermal_diffusivity PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/thermal_diffusivity-tests/thermal_diffusivity-tests.cpp b/tests/refinement-tests/thermal_diffusivity-tests/thermal_diffusivity-tests.cpp
deleted file mode 100644
index 27e2fd8e..00000000
--- a/tests/refinement-tests/thermal_diffusivity-tests/thermal_diffusivity-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/thermal_diffusivity.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("thermal_diffusivity refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::thermal_diffusivity_r> |= quantity_t<systems::si::thermal_diffusivity_t>{}) == quantity_t<systems::si::thermal_diffusivity_t>{});
-}
-
diff --git a/tests/refinement-tests/thermal_expansion_coefficient-tests/CMakeLists.txt b/tests/refinement-tests/thermal_expansion_coefficient-tests/CMakeLists.txt
deleted file mode 100644
index 4e694a86..00000000
--- a/tests/refinement-tests/thermal_expansion_coefficient-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building thermal_expansion_coefficient test")
-
-set(target thermal_expansion_coefficient-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources thermal_expansion_coefficient-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(thermal_expansion_coefficient "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(thermal_expansion_coefficient PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/thermal_expansion_coefficient-tests/thermal_expansion_coefficient-tests.cpp b/tests/refinement-tests/thermal_expansion_coefficient-tests/thermal_expansion_coefficient-tests.cpp
deleted file mode 100644
index 69b6966d..00000000
--- a/tests/refinement-tests/thermal_expansion_coefficient-tests/thermal_expansion_coefficient-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/thermal_expansion_coefficient.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("thermal_expansion_coefficient refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::thermal_expansion_coefficient_r> |= quantity_t<systems::si::thermal_expansion_coefficient_t>{}) == quantity_t<systems::si::thermal_expansion_coefficient_t>{});
-}
-
diff --git a/tests/refinement-tests/thermal_resistance-tests/CMakeLists.txt b/tests/refinement-tests/thermal_resistance-tests/CMakeLists.txt
deleted file mode 100644
index c41b2225..00000000
--- a/tests/refinement-tests/thermal_resistance-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building thermal_resistance test")
-
-set(target thermal_resistance-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources thermal_resistance-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(thermal_resistance "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(thermal_resistance PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/thermal_resistance-tests/thermal_resistance-tests.cpp b/tests/refinement-tests/thermal_resistance-tests/thermal_resistance-tests.cpp
deleted file mode 100644
index 0c0f67cf..00000000
--- a/tests/refinement-tests/thermal_resistance-tests/thermal_resistance-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/thermal_resistance.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("thermal_resistance refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::thermal_resistance_r> |= quantity_t<systems::si::thermal_resistance_t>{}) == quantity_t<systems::si::thermal_resistance_t>{});
-}
-
diff --git a/tests/refinement-tests/torque-tests/CMakeLists.txt b/tests/refinement-tests/torque-tests/CMakeLists.txt
deleted file mode 100644
index b4a89d9d..00000000
--- a/tests/refinement-tests/torque-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building torque test")
-
-set(target torque-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources torque-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(torque "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(torque PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/torque-tests/torque-tests.cpp b/tests/refinement-tests/torque-tests/torque-tests.cpp
deleted file mode 100644
index 55209938..00000000
--- a/tests/refinement-tests/torque-tests/torque-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/torque.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("torque refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::torque_r> |= quantity_t<systems::si::torque_t>{}) == quantity_t<systems::si::torque_t>{});
-}
-
diff --git a/tests/refinement-tests/velocity-tests/CMakeLists.txt b/tests/refinement-tests/velocity-tests/CMakeLists.txt
deleted file mode 100644
index ae24649f..00000000
--- a/tests/refinement-tests/velocity-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building velocity test")
-
-set(target velocity-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources velocity-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(velocity "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(velocity PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/velocity-tests/velocity-tests.cpp b/tests/refinement-tests/velocity-tests/velocity-tests.cpp
deleted file mode 100644
index e0126672..00000000
--- a/tests/refinement-tests/velocity-tests/velocity-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/velocity.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("velocity refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::velocity_r> |= quantity_t<systems::si::velocity_t>{}) == quantity_t<systems::si::velocity_t>{});
-}
-
diff --git a/tests/refinement-tests/voltage-tests/CMakeLists.txt b/tests/refinement-tests/voltage-tests/CMakeLists.txt
deleted file mode 100644
index 43ffdc59..00000000
--- a/tests/refinement-tests/voltage-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building voltage test")
-
-set(target voltage-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources voltage-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(voltage "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(voltage PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/voltage-tests/voltage-tests.cpp b/tests/refinement-tests/voltage-tests/voltage-tests.cpp
deleted file mode 100644
index 6e1cd262..00000000
--- a/tests/refinement-tests/voltage-tests/voltage-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/voltage.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("voltage refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::voltage_r> |= quantity_t<systems::si::voltage_t>{}) == quantity_t<systems::si::voltage_t>{});
-}
-
diff --git a/tests/refinement-tests/volume-tests/CMakeLists.txt b/tests/refinement-tests/volume-tests/CMakeLists.txt
deleted file mode 100644
index 4609e142..00000000
--- a/tests/refinement-tests/volume-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building volume test")
-
-set(target volume-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources volume-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(volume "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(volume PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/volume-tests/volume-tests.cpp b/tests/refinement-tests/volume-tests/volume-tests.cpp
deleted file mode 100644
index 16bec3f9..00000000
--- a/tests/refinement-tests/volume-tests/volume-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/volume.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("volume refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::volume_r> |= quantity_t<systems::si::volume_t>{}) == quantity_t<systems::si::volume_t>{});
-}
-
diff --git a/tests/refinement-tests/volumetric_flow-tests/CMakeLists.txt b/tests/refinement-tests/volumetric_flow-tests/CMakeLists.txt
deleted file mode 100644
index 10cb7486..00000000
--- a/tests/refinement-tests/volumetric_flow-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building volumetric_flow test")
-
-set(target volumetric_flow-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources volumetric_flow-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(volumetric_flow "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(volumetric_flow PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/volumetric_flow-tests/volumetric_flow-tests.cpp b/tests/refinement-tests/volumetric_flow-tests/volumetric_flow-tests.cpp
deleted file mode 100644
index 9f18059a..00000000
--- a/tests/refinement-tests/volumetric_flow-tests/volumetric_flow-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/volumetric_flow.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("volumetric_flow refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::volumetric_flow_r> |= quantity_t<systems::si::volumetric_flow_t>{}) == quantity_t<systems::si::volumetric_flow_t>{});
-}
-
diff --git a/tests/refinement-tests/wavenumber-tests/CMakeLists.txt b/tests/refinement-tests/wavenumber-tests/CMakeLists.txt
deleted file mode 100644
index ea3653b7..00000000
--- a/tests/refinement-tests/wavenumber-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building wavenumber test")
-
-set(target wavenumber-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources wavenumber-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(wavenumber "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(wavenumber PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/wavenumber-tests/wavenumber-tests.cpp b/tests/refinement-tests/wavenumber-tests/wavenumber-tests.cpp
deleted file mode 100644
index 5b763a4b..00000000
--- a/tests/refinement-tests/wavenumber-tests/wavenumber-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/wavenumber.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("wavenumber refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::wavenumber_r> |= quantity_t<systems::si::wavenumber_t>{}) == quantity_t<systems::si::wavenumber_t>{});
-}
-
diff --git a/tests/refinement-tests/weight-tests/CMakeLists.txt b/tests/refinement-tests/weight-tests/CMakeLists.txt
deleted file mode 100644
index 5cd84825..00000000
--- a/tests/refinement-tests/weight-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building weight test")
-
-set(target weight-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources weight-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(weight "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(weight PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/weight-tests/weight-tests.cpp b/tests/refinement-tests/weight-tests/weight-tests.cpp
deleted file mode 100644
index 4a9f05c8..00000000
--- a/tests/refinement-tests/weight-tests/weight-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/weight.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("weight refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::weight_r> |= quantity_t<systems::si::weight_t>{}) == quantity_t<systems::si::weight_t>{});
-}
-
diff --git a/tests/refinement-tests/work-tests/CMakeLists.txt b/tests/refinement-tests/work-tests/CMakeLists.txt
deleted file mode 100644
index 4e151f9b..00000000
--- a/tests/refinement-tests/work-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building work test")
-
-set(target work-refinement-test)
-message(STATUS "Building library ${target}")
-
-set(sources work-tests.cpp)
-
-add_executable(${target} ${sources})
-add_test(work "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(work PROPERTIES LABELS "refinement")
diff --git a/tests/refinement-tests/work-tests/work-tests.cpp b/tests/refinement-tests/work-tests/work-tests.cpp
deleted file mode 100644
index 78ed9d6d..00000000
--- a/tests/refinement-tests/work-tests/work-tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-#include <mitama/dimensional/systems/si/all.hpp>
-#include <mitama/dimensional/systems/si/derived_units/work.hpp>
-#include <mitama/dimensional/refinement.hpp>
-#include <test_util.hpp>
-
-using namespace mitama;
-using namespace mitama::systems::si;
-
-TEST_CASE("work refinement test", "[quantity][refinement]") {
-  REQUIRE((mitama::accepts<systems::si::work_r> |= quantity_t<systems::si::work_t>{}) == quantity_t<systems::si::work_t>{});
-}
-
diff --git a/tests/static-quantity-tests/CMakeLists.txt b/tests/static-quantity-tests/CMakeLists.txt
deleted file mode 100644
index 62358381..00000000
--- a/tests/static-quantity-tests/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-message(STATUS "Building static-quantity test")
-
-set(target static-quantity-tests)
-message(STATUS "Building library ${target}")
-
-set(sources static-quantity-tests.cpp tests-main.cpp)
-
-add_executable(${target} ${sources})
-add_test(static-quantity "${EXECUTABLE_OUTPUT_PATH}/${target}")
-set_tests_properties(static-quantity PROPERTIES LABELS "static-quantity")
diff --git a/tests/static-quantity-tests/static-quantity-tests.cpp b/tests/static-quantity-tests/static-quantity-tests.cpp
deleted file mode 100644
index 974fbc02..00000000
--- a/tests/static-quantity-tests/static-quantity-tests.cpp
+++ /dev/null
@@ -1,80 +0,0 @@
-// main is provided in tests-main.cpp
-#include <mitama/dimensional/quantity.hpp>
-#include <mitama/dimensional/static_quantity.hpp>
-#include <mitama/dimensional/systems/si/base_units/meter.hpp>
-#include <mitama/dimensional/io.hpp>
-#include <iostream>
-#include <catch2/catch.hpp>
-
-template < auto Arg >
-struct is_even: std::bool_constant<Arg % 2 == 0> {};
-
-template < auto Arg >
-struct is_odd: std::bool_constant<Arg % 2 == 1> {};
-
-namespace si = mitama::systems::si;
-using mitama::static_quantity, mitama::refined, mitama::quantity_t;
-using namespace mitama::literals::static_quantity_literals;
-
-TEMPLATE_TEST_CASE("static-quantity instantiation",
-                   "[static-quantity]",
-                   si::meter_t, si::kilogram_t, si::ampere_t, si::candela_t, si::second_t, si::mol_t, si::kelvin_t)
-{
-    REQUIRE(std::decay_t<decltype(static_quantity<TestType, 1>)>::value == 1);
-    REQUIRE(std::decay_t<decltype(static_quantity<TestType, -1>)>::value == -1);
-}
-
-TEMPLATE_TEST_CASE("static-quantity underlying type",
-                   "[static-quantity]",
-                   short, int, long, long long, unsigned, unsigned long, unsigned long long)
-{
-    REQUIRE(std::is_same_v<typename std::decay_t<decltype(static_quantity<si::meter_t, TestType{}>)>::value_type, TestType>);
-}
-
-TEST_CASE("static-quantity literals",
-          "[static-quantity]")
-{
-    REQUIRE(get(1_m) == 1);
-    REQUIRE(get(1_mm) == 1);
-    REQUIRE(get(1_km) == 1);
-
-    REQUIRE(get(1_s) == 1);
-    REQUIRE(get(1_ms) == 1);
-    REQUIRE(get(1_us) == 1);
-    REQUIRE(get(1_ns) == 1);
-
-    REQUIRE(get(1_mA) == 1);
-    REQUIRE(get(1_A) == 1);
-    REQUIRE(get(1_kA) == 1);
-
-    REQUIRE(get(1_mg) == 1);
-    REQUIRE(get(1_g) == 1);
-    REQUIRE(get(1_kg) == 1);
-
-    REQUIRE(get(1_K) == 1);
-    REQUIRE(get(1_mK) == 1);
-
-    REQUIRE(get(1_mol) == 1);
-    REQUIRE(get(1_mmol) == 1);
-
-    REQUIRE(get(1_cd) == 1);
-}
-
-TEMPLATE_TEST_CASE("static-quantity refinement",
-                   "[static-quantity]",
-                   si::meter_t, si::kilogram_t, si::ampere_t, si::candela_t, si::second_t, si::mol_t, si::kelvin_t)
-{
-    REQUIRE(refined<is_even, quantity_t<TestType, int>>(static_quantity<TestType, 2>).get() == quantity_t<TestType, int>(2));
-}
-
-TEMPLATE_TEST_CASE("static-quantity negation",
-                   "[static-quantity]",
-                   si::meter_t, si::kilogram_t, si::ampere_t, si::candela_t, si::second_t, si::mol_t, si::kelvin_t)
-{
-    constexpr auto _1 = static_quantity<TestType, 2>;
-    REQUIRE(get(_1) == 2);
-    constexpr auto _2 = -_1;
-    REQUIRE(get(_2) == -2);
-    constexpr auto _3 = -_2;
-    REQUIRE(get(_3) == 2);
-}