si_derived.hpp

Go to the documentation of this file.

#pragma once
#include "si_base.hpp"
#include <utility>
namespace Si {
namespace Derived {
template <typename T>
using Hertz = decltype(std::declval<Internal::Dimensionless<T>>() /
                       std::declval<Base::Second<T>>());
template <typename T>
using Newton = decltype(
    std::declval<Base::Kilogram<T>>() * std::declval<Base::Meter<T>>() /
    (std::declval<Base::Second<T>>() * std::declval<Base::Second<T>>()));
template <typename T>
using Pascal =
    decltype(std::declval<Newton<T>>() /
             (std::declval<Base::Meter<T>>() * std::declval<Base::Meter<T>>()));
template <typename T>
using Joule =
    decltype(std::declval<Base::Meter<T>>() * std::declval<Newton<T>>());
template <typename T>
using Watt =
    decltype(std::declval<Joule<T>>() / std::declval<Base::Second<T>>());
template <typename T>
using Coulomb =
    decltype(std::declval<Base::Second<T>>() * std::declval<Base::Ampere<T>>());
template <typename T>
using Volt =
    decltype(std::declval<Watt<T>>() / std::declval<Base::Ampere<T>>());
template <typename T>
using Farad = decltype(std::declval<Coulomb<T>>() / std::declval<Volt<T>>());
template <typename T>
using Ohm = decltype(std::declval<Volt<T>>() / std::declval<Base::Ampere<T>>());
template <typename T>
using Siemens =
    decltype(std::declval<Base::Ampere<T>>() / std::declval<Volt<T>>());
template <typename T>
using Weber =
    decltype(std::declval<Joule<T>>() / std::declval<Base::Ampere<T>>());
template <typename T>
using Tesla =
    decltype(std::declval<Newton<T>>() / (std::declval<Base::Ampere<T>>() *
                                          std::declval<Base::Meter<T>>()));
template <typename T>
using Henry =
    decltype(std::declval<Weber<T>>() / std::declval<Base::Ampere<T>>());
template <typename T> using Lumen = Base::Candela<T>;
template <typename T>
using Lux =
    decltype(std::declval<Lumen<T>>() /
             (std::declval<Base::Meter<T>>() * std::declval<Base::Meter<T>>()));
template <typename T> using Becquerel = Hertz<T>;
template <typename T>
using Gray =
    decltype(std::declval<Joule<T>>() / std::declval<Base::Kilogram<T>>());
template <typename T> using Sievert = Gray<T>;
template <typename T>
using Katal =
    decltype(std::declval<Base::Mole<T>>() / std::declval<Base::Second<T>>());
namespace Literals {
Hertz<long double> operator"" _Hz(long double value) {
  return Hertz<long double>(value);
}
Newton<long double> operator"" _N(long double value) {
  return Newton<long double>(value);
}
Pascal<long double> operator"" _Pa(long double value) {
  return Pascal<long double>(value);
}
Joule<long double> operator"" _J(long double value) {
  return Joule<long double>(value);
}
Watt<long double> operator"" _W(long double value) {
  return Watt<long double>(value);
}
Coulomb<long double> operator"" _C(long double value) {
  return Coulomb<long double>(value);
}
Volt<long double> operator"" _V(long double value) {
  return Volt<long double>(value);
}
Farad<long double> operator"" _F(long double value) {
  return Farad<long double>(value);
}
Ohm<long double> operator"" _Ohm(long double value) {
  return Ohm<long double>(value);
}
Siemens<long double> operator"" _S(long double value) {
  return Siemens<long double>(value);
}
Weber<long double> operator"" _Wb(long double value) {
  return Weber<long double>(value);
}
Tesla<long double> operator"" _T(long double value) {
  return Tesla<long double>(value);
}
Henry<long double> operator"" _H(long double value) {
  return Henry<long double>(value);
}
Lumen<long double> operator"" _lm(long double value) {
  return Lumen<long double>(value);
}
Lux<long double> operator"" _lx(long double value) {
  return Lux<long double>(value);
}
Becquerel<long double> operator"" _Bq(long double value) {
  return Becquerel<long double>(value);
}
Gray<long double> operator"" _Gy(long double value) {
  return Gray<long double>(value);
}
Sievert<long double> operator"" _Sv(long double value) {
  return Sievert<long double>(value);
}
Katal<long double> operator"" _kat(long double value) {
  return Katal<long double>(value);
}
} // namespace Literals
} // namespace Derived
} // namespace Si