// SPDX-License-Identifier: Apache-2.0 // // Copyright 2008-2016 Conrad Sanderson (https://conradsanderson.id.au) // Copyright 2008-2016 National ICT Australia (NICTA) // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // https://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // ------------------------------------------------------------------------ //! \addtogroup constants //! @{ namespace priv { struct Datum_helper { template static constexpr typename arma_real_only::result nan(typename arma_real_only::result* junk = nullptr) { arma_ignore(junk); return (std::numeric_limits::has_quiet_NaN) ? eT(std::numeric_limits::quiet_NaN()) : eT(0); } template static constexpr typename arma_cx_only::result nan(typename arma_cx_only::result* junk = nullptr) { arma_ignore(junk); typedef typename get_pod_type::result T; return eT( Datum_helper::nan(), Datum_helper::nan() ); } template static constexpr typename arma_integral_only::result nan(typename arma_integral_only::result* junk = nullptr) { arma_ignore(junk); return eT(0); } // template static constexpr typename arma_real_only::result pos_inf(typename arma_real_only::result* junk = nullptr) { arma_ignore(junk); return (std::numeric_limits::has_infinity) ? eT(std::numeric_limits::infinity()) : eT(std::numeric_limits::max()); } template static constexpr typename arma_cx_only::result pos_inf(typename arma_cx_only::result* junk = nullptr) { arma_ignore(junk); typedef typename get_pod_type::result T; return eT( Datum_helper::pos_inf(), Datum_helper::pos_inf() ); } template static constexpr typename arma_integral_only::result pos_inf(typename arma_integral_only::result* junk = nullptr) { arma_ignore(junk); return std::numeric_limits::max(); } // template static constexpr typename arma_real_only::result neg_inf(typename arma_real_only::result* junk = nullptr) { arma_ignore(junk); return (std::numeric_limits::has_infinity) ? eT(-std::numeric_limits::infinity()) : eT(std::numeric_limits::lowest()); } template static constexpr typename arma_cx_only::result neg_inf(typename arma_cx_only::result* junk = nullptr) { arma_ignore(junk); typedef typename get_pod_type::result T; return eT( Datum_helper::neg_inf(), Datum_helper::neg_inf() ); } template static constexpr typename arma_integral_only::result neg_inf(typename arma_integral_only::result* junk = nullptr) { arma_ignore(junk); return std::numeric_limits::lowest(); } }; } //! various constants. //! Physical constants taken from NIST 2018 CODATA values, and some from WolframAlpha (values provided as of 2009-06-23) //! http://physics.nist.gov/cuu/Constants //! http://www.wolframalpha.com //! See also http://en.wikipedia.org/wiki/Physical_constant template struct Datum { static const eT pi; //!< ratio of any circle's circumference to its diameter static const eT tau; //!< ratio of any circle's circumference to its radius (replacement of 2*pi) static const eT e; //!< base of the natural logarithm static const eT euler; //!< Euler's constant, aka Euler-Mascheroni constant static const eT gratio; //!< golden ratio static const eT sqrt2; //!< square root of 2 static const eT sqrt2pi; //!< square root of 2*pi static const eT log_sqrt2pi; //!< log of square root of 2*pi static const eT eps; //!< the difference between 1 and the least value greater than 1 that is representable static const eT log_min; //!< log of the minimum representable value static const eT log_max; //!< log of the maximum representable value static const eT nan; //!< "not a number" static const eT inf; //!< positive infinity static const eT pos_inf; //!< positive infinity static const eT neg_inf; //!< negative infinity // static const eT m_u; //!< atomic mass constant (in kg) static const eT N_A; //!< Avogadro constant static const eT k; //!< Boltzmann constant (in joules per kelvin) static const eT k_evk; //!< Boltzmann constant (in eV/K) static const eT a_0; //!< Bohr radius (in meters) static const eT mu_B; //!< Bohr magneton static const eT Z_0; //!< characteristic impedance of vacuum (in ohms) static const eT G_0; //!< conductance quantum (in siemens) static const eT k_e; //!< Coulomb's constant (in meters per farad) static const eT eps_0; //!< electric constant (in farads per meter) static const eT m_e; //!< electron mass (in kg) static const eT eV; //!< electron volt (in joules) static const eT ec; //!< elementary charge (in coulombs) static const eT F; //!< Faraday constant (in coulombs) static const eT alpha; //!< fine-structure constant static const eT alpha_inv; //!< inverse fine-structure constant static const eT K_J; //!< Josephson constant static const eT mu_0; //!< magnetic constant (in henries per meter) static const eT phi_0; //!< magnetic flux quantum (in webers) static const eT R; //!< molar gas constant (in joules per mole kelvin) static const eT G; //!< Newtonian constant of gravitation (in newton square meters per kilogram squared) static const eT h; //!< Planck constant (in joule seconds) static const eT h_bar; //!< Planck constant over 2 pi, aka reduced Planck constant (in joule seconds) static const eT m_p; //!< proton mass (in kg) static const eT R_inf; //!< Rydberg constant (in reciprocal meters) static const eT c_0; //!< speed of light in vacuum (in meters per second) static const eT sigma; //!< Stefan-Boltzmann constant static const eT R_k; //!< von Klitzing constant (in ohms) static const eT b; //!< Wien wavelength displacement law constant }; // the long lengths of the constants are for future support of "long double" // and any smart compiler that does high-precision computation at compile-time template const eT Datum::pi = eT(3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679); template const eT Datum::tau = eT(6.2831853071795864769252867665590057683943387987502116419498891846156328125724179972560696506842341359); template const eT Datum::e = eT(2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251664274); template const eT Datum::euler = eT(0.5772156649015328606065120900824024310421593359399235988057672348848677267776646709369470632917467495); template const eT Datum::gratio = eT(1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374); template const eT Datum::sqrt2 = eT(1.4142135623730950488016887242096980785696718753769480731766797379907324784621070388503875343276415727); template const eT Datum::sqrt2pi = eT(2.5066282746310005024157652848110452530069867406099383166299235763422936546078419749465958383780572661); template const eT Datum::log_sqrt2pi = eT(0.9189385332046727417803297364056176398613974736377834128171515404827656959272603976947432986359541976); template const eT Datum::eps = std::numeric_limits::epsilon(); template const eT Datum::log_min = std::log(std::numeric_limits::min()); template const eT Datum::log_max = std::log(std::numeric_limits::max()); template const eT Datum::nan = priv::Datum_helper::nan(); template const eT Datum::inf = priv::Datum_helper::pos_inf(); template const eT Datum::pos_inf = priv::Datum_helper::pos_inf(); template const eT Datum::neg_inf = priv::Datum_helper::neg_inf(); template const eT Datum::m_u = eT(1.66053906892e-27); template const eT Datum::N_A = eT(6.02214076e23); template const eT Datum::k = eT(1.380649e-23); template const eT Datum::k_evk = eT(8.617333262e-5); template const eT Datum::a_0 = eT(5.29177210544e-11); template const eT Datum::mu_B = eT(9.2740100657e-24); template const eT Datum::Z_0 = eT(376.730313412); template const eT Datum::G_0 = eT(7.748091729e-5); template const eT Datum::k_e = eT(8.9875517923e9); template const eT Datum::eps_0 = eT(8.8541878128e-12); template const eT Datum::m_e = eT(9.1093837139e-31); template const eT Datum::eV = eT(1.602176634e-19); template const eT Datum::ec = eT(1.602176634e-19); template const eT Datum::F = eT(96485.33212); template const eT Datum::alpha = eT(7.2973525643e-3); template const eT Datum::alpha_inv = eT(137.035999177); template const eT Datum::K_J = eT(483597.8484e9); template const eT Datum::mu_0 = eT(1.25663706212e-6); template const eT Datum::phi_0 = eT(2.067833848e-15); template const eT Datum::R = eT(8.314462618); template const eT Datum::G = eT(6.67430e-11); template const eT Datum::h = eT(6.62607015e-34); template const eT Datum::h_bar = eT(1.054571817e-34); template const eT Datum::m_p = eT(1.67262192595e-27); template const eT Datum::R_inf = eT(10973731.568157); template const eT Datum::c_0 = eT(299792458.0); template const eT Datum::sigma = eT(5.670374419e-8); template const eT Datum::R_k = eT(25812.80745); template const eT Datum::b = eT(2.897771955e-3); typedef Datum fdatum; typedef Datum datum; namespace priv { template static constexpr typename arma_real_only::result most_neg() { return (std::numeric_limits::has_infinity) ? -(std::numeric_limits::infinity()) : std::numeric_limits::lowest(); } template static constexpr typename arma_integral_only::result most_neg() { return std::numeric_limits::lowest(); } template static constexpr typename arma_real_only::result most_pos() { return (std::numeric_limits::has_infinity) ? std::numeric_limits::infinity() : std::numeric_limits::max(); } template static constexpr typename arma_integral_only::result most_pos() { return std::numeric_limits::max(); } } //! @}