f1x1t/myxlib
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Математические функции перенесены в отдельную библиотеку

Browse Source
This commit is contained in:
Andrei Astafev
2020-04-27 11:13:15 +03:00
parent d264077648
commit 00be8cd00f
17 changed files with 0 additions and 807 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -43,7 +43,6 @@ find_package(Qt5 COMPONENTS Core Network REQUIRED)
add_subdirectory(src/myx/base)
add_subdirectory(src/myx/filesystem)
add_subdirectory(src/myx/qt)
add_subdirectory(src/myx/math)
# Примеры
if(MYXLIB_BUILD_EXAMPLES OR MYXLIB_BUILD_EXAMPLES_HO)

72
src/myx/math/CMakeLists.txt
View File

@ -1,72 +0,0 @@
# Название основной цели и имя библиотеки в текущем каталоге
set(TRGT math)
# cmake-format: off
# Список файлов исходных текстов
set(TRGT_cpp
${CMAKE_CURRENT_SOURCE_DIR}/almost_equal_relative.cpp
${CMAKE_CURRENT_SOURCE_DIR}/almost_equal_relative_and_abs.cpp
${CMAKE_CURRENT_SOURCE_DIR}/almost_equal_ulps.cpp
${CMAKE_CURRENT_SOURCE_DIR}/almost_equal_ulps_and_abs.cpp
${CMAKE_CURRENT_SOURCE_DIR}/constants.cpp)
# Список заголовочных файлов
set(TRGT_hpp
${CMAKE_CURRENT_SOURCE_DIR}/all.hpp
${CMAKE_CURRENT_SOURCE_DIR}/almost_equal_relative.hpp
${CMAKE_CURRENT_SOURCE_DIR}/almost_equal_relative_and_abs.hpp
${CMAKE_CURRENT_SOURCE_DIR}/almost_equal_ulps.hpp
${CMAKE_CURRENT_SOURCE_DIR}/almost_equal_ulps_and_abs.hpp
${CMAKE_CURRENT_SOURCE_DIR}/constants.hpp
${CMAKE_CURRENT_SOURCE_DIR}/float_cmp_types.hpp
${CMAKE_CURRENT_SOURCE_DIR}/functions.hpp
${CMAKE_CURRENT_SOURCE_DIR}/radar.hpp
${CMAKE_CURRENT_SOURCE_DIR}/units.hpp)
set(TRGT_headers ${TRGT_hpp})
# cmake-format: on
add_library(${TRGT}-header-only INTERFACE)
target_sources(${TRGT}-header-only INTERFACE ${TRGT_headers})
target_include_directories(
${TRGT}-header-only SYSTEM INTERFACE "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
"$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
if(MYXLIB_BUILD_LIBRARIES)
add_common_library(${TRGT} OUTPUT_NAME myx-${TRGT} SOURCES ${TRGT_cpp} ${TRGT_headers})
common_target_properties(${TRGT})
# Создание цели для проверки утилитой clang-tidy
add_clang_tidy_check(${TRGT} ${TRGT_sources} ${TRGT_headers})
# Создание цели для проверки утилитой clang-analyze
add_clang_analyze_check(${TRGT} ${TRGT_sources} ${TRGT_headers})
# Создание цели для проверки утилитой clazy
add_clazy_check(${TRGT} ${TRGT_sources} ${TRGT_headers})
# Создание цели для проверки утилитой pvs-studio
add_pvs_check(${TRGT})
# Создание цели для автоматического форматирования кода
add_format_sources(${TRGT} ${TRGT_sources} ${TRGT_headers})
target_compile_definitions(${TRGT} PUBLIC MYXLIB_BUILD_LIBRARIES)
target_include_directories(${TRGT} SYSTEM PRIVATE ${CMAKE_SOURCE_DIR}/src)
cotire(${TRGT})
install(TARGETS ${TRGT}_static COMPONENT libs-dev ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
if(BUILD_SHARED_LIBS)
install(TARGETS ${TRGT}_shared COMPONENT main LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
endif()
else()
install(FILES ${TRGT_cpp} COMPONENT base-dev DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}/${TRGT})
endif()
generate_pkgconfig(myx-${TRGT} COMPONENT base-dev INSTALL_LIBRARY ${MYXLIB_BUILD_LIBRARIES})
install(FILES ${TRGT_headers} COMPONENT base-dev DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}/${TRGT})
# Цель, используемая только для установки заголовочных файлов без компиляции проекта
add_custom_target(${TRGT}-install-headers COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_COMPONENT=base -P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")

15
src/myx/math/all.hpp
View File

@ -1,15 +0,0 @@
#ifndef MYX_MATH_ALL_HPP_
#define MYX_MATH_ALL_HPP_
#pragma once
#include <myx/math/almost_equal_relative.hpp>
#include <myx/math/almost_equal_relative_and_abs.hpp>
#include <myx/math/almost_equal_ulps.hpp>
#include <myx/math/almost_equal_ulps_and_abs.hpp>
#include <myx/math/constants.hpp>
#include <myx/math/functions.hpp>
#include <myx/math/radar.hpp>
#include <myx/math/units.hpp>
#endif

51
src/myx/math/almost_equal_relative.cpp
View File

@ -1,51 +0,0 @@
#ifndef MYX_MATH_ALMOST_EQUAL_RELATIVE_CPP_
#define MYX_MATH_ALMOST_EQUAL_RELATIVE_CPP_
#ifndef MYXLIB_HEADER_ONLY
#include <myx/math/almost_equal_relative.hpp>
#else
#pragma once
#endif
#include <cmath>
namespace myx {
namespace math {
MYXLIB_INLINE bool almost_equal_relative( const float a, const float b,
const float maxRelDiff )
{
float diff = fabsf( a - b );
float aN = fabsf( a );
float bN = fabsf( b );
float largest = ( bN > aN ) ? bN : aN;
if ( diff <= largest * maxRelDiff )
{
return( true );
}
return( false );
}
MYXLIB_INLINE bool almost_equal_relative( const double a, const double b,
const double maxRelDiff )
{
double diff = fabs( a - b );
double aN = fabs( a );
double bN = fabs( b );
double largest = ( bN > aN ) ? bN : aN;
if ( diff <= largest * maxRelDiff )
{
return( true );
}
return( false );
}
} // namespace math
} // namespace myx
#endif // ifndef MYX_MATH_ALMOST_EQUAL_RELATIVE_CPP_

39
src/myx/math/almost_equal_relative.hpp
View File

@ -1,39 +0,0 @@
#ifndef MYX_MATH_ALMOST_EQUAL_RELATIVE_HPP_
#define MYX_MATH_ALMOST_EQUAL_RELATIVE_HPP_
#pragma once
#include <myx/base/config.hpp>
#include <cfloat>
// https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
namespace myx {
namespace math {
/**
* @brief Проверка на равенство двух аргументов типа float.
* Параметр maxRelDiff определяет максимальную относительную допустимую разницу,
* при которой аргументы считаются равными.
*/
bool almost_equal_relative( float a, float b,
float maxRelDiff = FLT_EPSILON );
/**
* @brief Проверка на равенство двух аргументов типа double.
* Параметр maxRelDiff определяет максимальную относительную допустимую разницу,
* при которой аргументы считаются равными.
*/
bool almost_equal_relative( double a, double b,
double maxRelDiff = DBL_EPSILON );
} // namespace math
} // namespace myx
#ifdef MYXLIB_HEADER_ONLY
#include "almost_equal_relative.cpp"
#endif
#endif // MYX_MATH_ALMOST_EQUAL_RELATIVE_HPP_

65
src/myx/math/almost_equal_relative_and_abs.cpp
View File

@ -1,65 +0,0 @@
#ifndef MYX_MATH_ALMOST_EQUAL_RELATIVE_AND_ABS_CPP_
#define MYX_MATH_ALMOST_EQUAL_RELATIVE_AND_ABS_CPP_
#ifndef MYXLIB_HEADER_ONLY
#include <myx/math/almost_equal_relative_and_abs.hpp>
#else
#pragma once
#endif
#include <cmath>
namespace myx {
namespace math {
MYXLIB_INLINE bool almost_equal_relative_and_abs( const float a, const float b,
const float maxAbsDiff, const float maxRelDiff )
{
// Check if the numbers are really close -- needed
// when comparing numbers near zero.
float diff = fabsf( a - b );
if ( diff <= maxAbsDiff )
{
return( true );
}
float aN = fabsf( a );
float bN = fabsf( b );
float largest = ( bN > aN ) ? bN : aN;
if ( diff <= largest * maxRelDiff )
{
return( true );
}
return( false );
}
MYXLIB_INLINE bool almost_equal_relative_and_abs( const double a, const double b,
const double maxAbsDiff, const double maxRelDiff )
{
// Check if the numbers are really close -- needed
// when comparing numbers near zero.
double diff = fabs( a - b );
if ( diff <= maxAbsDiff )
{
return( true );
}
double aN = fabs( a );
double bN = fabs( b );
double largest = ( bN > aN ) ? bN : aN;
if ( diff <= largest * maxRelDiff )
{
return( true );
}
return( false );
}
} // namespace math
} // namespace myx
#endif // ifndef MYX_MATH_ALMOST_EQUAL_RELATIVE_AND_ABS_CPP_

39
src/myx/math/almost_equal_relative_and_abs.hpp
View File

@ -1,39 +0,0 @@
#ifndef MYX_MATH_ALMOST_EQUAL_RELATIVE_AND_ABS_HPP_
#define MYX_MATH_ALMOST_EQUAL_RELATIVE_AND_ABS_HPP_
#pragma once
#include <myx/base/config.hpp>
#include <cfloat>
namespace myx {
namespace math {
/**
* @brief Проверка на равенство двух аргументов типа float.
* Параметр maxAbsDiff определяет максимальную абсолютную допустимую разницу.
* Параметр maxRelDiff определяет максимальную относительную допустимую разницу,
* при которой аргументы считаются равными.
*/
bool almost_equal_relative_and_abs( float a, float b,
float maxAbsDiff, float maxRelDiff = FLT_EPSILON );
/**
* @brief Проверка на равенство двух аргументов типа double.
* Параметр maxAbsDiff определяет максимальную абсолютную допустимую разницу.
* Параметр maxRelDiff определяет максимальную относительную допустимую разницу,
* при которой аргументы считаются равными.
*/
bool almost_equal_relative_and_abs( double a, double b,
double maxAbsDiff, double maxRelDiff = DBL_EPSILON );
} // namespace math
} // namespace myx
#ifdef MYXLIB_HEADER_ONLY
#include "almost_equal_relative_and_abs.cpp"
#endif
#endif // MYX_MATH_ALMOST_EQUAL_RELATIVE_AND_ABS_HPP_

93
src/myx/math/almost_equal_ulps.cpp
View File

@ -1,93 +0,0 @@
#ifndef MYX_MATH_ALMOST_EQUAL_ULPS_CPP_
#define MYX_MATH_ALMOST_EQUAL_ULPS_CPP_
#ifndef MYXLIB_HEADER_ONLY
#include <myx/math/almost_equal_ulps.hpp>
#else
#pragma once
#endif
#include <myx/math/float_cmp_types.hpp>
#include <cmath>
namespace myx {
namespace math {
MYXLIB_INLINE bool almost_equal_ulps( const float a, const float b,
const int maxUlpsDiff )
{
FloatCmp uA( a );
FloatCmp uB( b );
// Если знаки разные, то числа не равны.
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-union-access)
if ( uA.negative() != uB.negative() )
{
// Кроме случая, когда +0==-0
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
#endif
if ( a == b ) // -V550
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
{
return( true );
}
return( false );
}
// Разница в младших битах.
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-union-access)
auto ulpsDiff = std::abs( uA.i - uB.i );
if ( ulpsDiff <= maxUlpsDiff )
{
return( true );
}
return( false );
} // almost_equal_ulps
MYXLIB_INLINE bool almost_equal_ulps( const double a, const double b,
const int maxUlpsDiff )
{
DoubleCmp uA( a );
DoubleCmp uB( b );
// Если знаки разные, то числа не равны.
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-union-access)
if ( uA.negative() != uB.negative() )
{
// Кроме случая, когда +0==-0
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
#endif
if ( a == b ) // -V550
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
{
return( true );
}
return( false );
}
// Разница в младших битах.
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-union-access)
auto ulpsDiff = std::abs( uA.i - uB.i );
if ( ulpsDiff <= maxUlpsDiff )
{
return( true );
}
return( false );
} // almost_equal_ulps
} // namespace math
} // namespace myx
#endif // ifndef MYX_MATH_ALMOST_EQUAL_ULPS_CPP_

38
src/myx/math/almost_equal_ulps.hpp
View File

@ -1,38 +0,0 @@
#ifndef MYX_MATH_ALMOST_EQUAL_ULPS_HPP_
#define MYX_MATH_ALMOST_EQUAL_ULPS_HPP_
#pragma once
#include <myx/base/config.hpp>
#include <myx/math/float_cmp_types.hpp>
#include <cmath>
namespace myx {
namespace math {
/**
* @brief Проверка на равенство двух аргументов типа float.
* Параметр maxUlpsDiff определяет максимальную разницу между аргументами,
* при которой они считаются равными.
*/
bool almost_equal_ulps( float a, float b,
int maxUlpsDiff );
/**
* @brief Проверка на равенство двух аргументов типа double.
* Параметр maxUlpsDiff определяет максимальную разницу между аргументами,
* при которой они считаются равными.
*/
bool almost_equal_ulps( double a, double b,
int maxUlpsDiff );
} // namespace math
} // namespace myx
#ifdef MYXLIB_HEADER_ONLY
#include "almost_equal_ulps.cpp"
#endif
#endif // MYX_MATH_ALMOST_EQUAL_ULPS_HPP_

87
src/myx/math/almost_equal_ulps_and_abs.cpp
View File

@ -1,87 +0,0 @@
#ifndef MYX_MATH_ALMOST_EQUAL_ULPS_CPP_
#define MYX_MATH_ALMOST_EQUAL_ULPS_CPP_
#ifndef MYXLIB_HEADER_ONLY
#include <myx/math/almost_equal_ulps_and_abs.hpp>
#else
#pragma once
#endif
#include <myx/math/float_cmp_types.hpp>
#include <cmath>
namespace myx {
namespace math {
MYXLIB_INLINE bool almost_equal_ulps_and_abs( const float a, const float b,
const float maxAbsDiff, const int maxUlpsDiff )
{
// Check if the numbers are really close -- needed
// when comparing numbers near zero.
float absDiff = fabsf( a - b );
if ( absDiff <= maxAbsDiff )
{
return( true );
}
FloatCmp uA( a );
FloatCmp uB( b );
// Different signs means they do not match.
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-union-access)
if ( uA.negative() != uB.negative() )
{
return( false );
}
// Find the difference in ULPs.
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-union-access)
int ulpsDiff = std::abs( uA.i - uB.i );
if ( ulpsDiff <= maxUlpsDiff )
{
return( true );
}
return( false );
} // almost_equal_ulps_and_abs
MYXLIB_INLINE bool almost_equal_ulps_and_abs( const double a, const double b,
const double maxAbsDiff, const int maxUlpsDiff )
{
// Check if the numbers are really close -- needed
// when comparing numbers near zero.
double absDiff = fabs( a - b );
if ( absDiff <= maxAbsDiff )
{
return( true );
}
DoubleCmp uA( a );
DoubleCmp uB( b );
// Different signs means they do not match.
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-union-access)
if ( uA.negative() != uB.negative() )
{
return( false );
}
// Find the difference in ULPs.
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-union-access)
auto ulpsDiff = std::abs( uA.i - uB.i );
if ( ulpsDiff <= maxUlpsDiff )
{
return( true );
}
return( false );
} // almost_equal_ulps_and_abs
} // namespace math
} // namespace myx
#endif // ifndef MYX_MATH_ALMOST_EQUAL_ULPS_CPP_

37
src/myx/math/almost_equal_ulps_and_abs.hpp
View File

@ -1,37 +0,0 @@
#ifndef MYX_MATH_ALMOST_EQUAL_ULPS_HPP_
#define MYX_MATH_ALMOST_EQUAL_ULPS_HPP_
#pragma once
#include <myx/base/config.hpp>
namespace myx {
namespace math {
/**
* @brief Проверка на равенство двух аргументов типа float.
* Параметр maxAbsDiff определяет максимальную абсолютную допустимую разницу.
* Параметр maxUlpsDiff определяет максимальную разницу между аргументами,
* при которой они считаются равными.
*/
bool almost_equal_ulps_and_abs( float a, float b,
float maxAbsDiff, int maxUlpsDiff );
/**
* @brief Проверка на равенство двух аргументов типа double.
* Параметр maxAbsDiff определяет максимальную абсолютную допустимую разницу.
* Параметр maxUlpsDiff определяет максимальную разницу между аргументами,
* при которой они считаются равными.
*/
bool almost_equal_ulps_and_abs( double a, double b,
double maxAbsDiff, int maxUlpsDiff );
} // namespace math
} // namespace myx
#ifdef MYXLIB_HEADER_ONLY
#include "almost_equal_ulps_and_abs.cpp"
#endif
#endif // MYX_MATH_ALMOST_EQUAL_ULPS_HPP_

18
src/myx/math/constants.cpp
View File

@ -1,18 +0,0 @@
#ifndef MYX_MATH_CONSTANTS_CPP_
#define MYX_MATH_CONSTANTS_CPP_
#ifndef MYXLIB_HEADER_ONLY
#include <myx/math/constants.hpp>
#else
#pragma once
#endif
namespace myx {
namespace math {
} // namespace math
} // namespace myx
#endif // ifndef MYX_MATH_CONSTANTS_CPP_

25
src/myx/math/constants.hpp
View File

@ -1,25 +0,0 @@
#ifndef MYX_MATH_CONSTANTS_HPP_
#define MYX_MATH_CONSTANTS_HPP_
#pragma once
#include <myx/base/config.hpp>
#include <cmath>
#include <type_traits>
namespace myx {
namespace math {
const auto ImpedanceOfFreeSpace = ( M_PI * 119.9169832 );
} // namespace math
} // namespace myx
#ifdef MYXLIB_HEADER_ONLY
#include "constants.cpp"
#endif
#endif // MYX_MATH_CONSTANTS_HPP_

56
src/myx/math/float_cmp_types.hpp
View File

@ -1,56 +0,0 @@
#ifndef MYX_MATH_FLOAT_CMP_TYPES_HPP_
#define MYX_MATH_FLOAT_CMP_TYPES_HPP_
#pragma once
#include <cstdint>
/**
* @brief Объединение для получения знака аргумента типа float.
*/
union FloatCmp
{
int32_t i;
float f;
/**
* @brief Инициализация.
*/
explicit FloatCmp( float num = 0.0F ) : f( num )
{
}
/**
* @brief Функция, возращающая true, если значение отрицательное
*/
bool negative() const
{
return( i < 0 );
}
};
/**
* @brief Объединение для получения знака аргумента типа double.
*/
union DoubleCmp
{
int64_t i;
double d;
/**
* @brief Инициализация.
*/
explicit DoubleCmp( double num = 0.0L ) : d( num )
{
}
/**
* @brief Функция, возращающая true, если значение отрицательное
*/
bool negative() const
{
return( i < 0 );
}
};
#endif // MYX_MATH_FLOAT_CMP_TYPES_HPP_

30
src/myx/math/functions.hpp
View File

@ -1,30 +0,0 @@
#ifndef MYX_MATH_FUNCTIONS_HPP_
#define MYX_MATH_FUNCTIONS_HPP_
#pragma once
#include <boost/math/special_functions/pow.hpp>
#include <cmath>
#include <type_traits>
namespace myx {
namespace math {
/*!
* \brief pow2 Возведение в квадрат
* \param value Значение
* \return Квадрат значения
*/
template < typename T >
auto pow2( T const& value ) -> decltype( boost::math::pow< 2 >( value ) )
{
return( boost::math::pow< 2 >( value ) );
}
} // namespace math
} // namespace myx
#endif // MYX_MATH_FUNCTIONS_HPP_

48
src/myx/math/radar.hpp
View File

@ -1,48 +0,0 @@
#ifndef MYX_MATH_RADAR_HPP_
#define MYX_MATH_RADAR_HPP_
#pragma once
#include <cmath>
#include <type_traits>
namespace myx {
namespace math {
/*!
* \brief geometric_target_visibility Геометрическая видимость цели
* \param earthRadius Радиус Земли
* \param antennaHeight Высота антенны
* \param targetHeight Высота цели
* \return Максимальная дальность видимости цели
*/
template < typename T >
T geometric_target_visibility( const T& earthRadius, const T& antennaHeight, const T& targetHeight )
{
// static_assert( std::is_arithmetic< T >::value || std::is_same< T, quantity< length_d > >::value, "Arithmetic type is required." );
static_assert( std::is_arithmetic< T >::value, "Arithmetic type is required." );
return ( sqrt( 2 * earthRadius * antennaHeight ) + sqrt( 2 * earthRadius * targetHeight ) );
}
/*!
* \brief radar_target_visibility Видимость цели по лучу
* \param earthRadius Радиус Земли
* \param antennaHeight Высота антенны
* \param targetHeight Высота цели
* \return Максимальная дальность видимости цели
*/
template < typename T >
T radar_target_visibility( T effectiveEarthRadius, T antennaHeight, T targetHeight )
{
// static_assert( std::is_arithmetic< T >::value || std::is_same< T, quantity< length_d > >::value, "Arithmetic type is required." );
static_assert( std::is_arithmetic< T >::value, "Arithmetic type is required." );
return ( sqrt( 2 * effectiveEarthRadius * antennaHeight ) + sqrt( 2 * effectiveEarthRadius * targetHeight ) );
}
} // namespace math
} // namespace myx
#endif // MYX_MATH_RADAR_HPP_

93
src/myx/math/units.hpp
View File

@ -1,93 +0,0 @@
#ifndef MYX_MATH_UNITS_HPP_
#define MYX_MATH_UNITS_HPP_
#pragma once
#include <cmath>
#include <type_traits>
namespace myx {
namespace math {
/*!
* \brief radians_to_degrees Перевод из радиан в градусы
* \param radians Значение в радианах
* \return Значение в градусах
*/
template < typename T >
T radians_to_degrees( const T& radians, typename std::enable_if< std::is_floating_point< T >::value >::type* /*unused*/ = 0 )
{
static_assert( std::is_arithmetic< T >::value, "Arithmetic type is required." );
return( radians * M_1_PI * 180.0 );
}
/*!
* \brief degrees_to_radians Перевод из градусов в радианы
* \param degrees Значение в градусах
* \return Значение в радианах
*/
template < typename T >
T degrees_to_radians( const T& degrees, typename std::enable_if< std::is_floating_point< T >::value >::type* /*unused*/ = 0 )
{
static_assert( std::is_arithmetic< T >::value, "Arithmetic type is required." );
return( degrees * M_PI / 180.0 );
}
/*!
* \brief decibel_to_power Перевод из децибелов в мощность $y = 10^{db / 10}$
* \param db Децибелы
* \return Мощность
*/
template < typename T >
T decibel_to_power( T const& db )
{
static_assert( std::is_arithmetic< T >::value, "Arithmetic type is required." );
return( std::pow( 10, db / 10.0 ) );
}
/*!
* \brief power_to_decibel Перевод из мощности в децибелы по формуле $y = 10 * \log(x)$
* \param power Мощность
* \return Децибелы
*/
template < typename T >
T power_to_decibel( T const& power )
{
static_assert( std::is_arithmetic< T >::value, "Arithmetic type is required." );
return( 10 * std::log( power ) );
}
/*!
* \brief decibel_to_power Перевод из децибелов в амплитуду $y = 10^{db / 20}$
* \param db Децибелы
* \return Амплитуда
*/template < typename T >
T decibel_to_magnitude( T const& db )
{
static_assert( std::is_arithmetic< T >::value, "Arithmetic type is required." );
return( std::pow( 10, db / 20.0 ) );
}
/*!
* \brief magnitude_to_decibel Перевод из амплитуды в децибелы по формуле $y = 20 * \log(x)$
* \param magnitude Амплитуда
* \return Децибелы
*/
template < typename T >
T magnitude_to_decibel( T const& magnitude )
{
static_assert( std::is_arithmetic< T >::value, "Arithmetic type is required." );
return( 20 * std::log( magnitude ) );
}
} // namespace math
} // namespace myx
#endif // MYX_MATH_UNITS_HPP_