math.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2020, Lawrence Livermore National Security, LLC and LvArray contributors.
 * All rights reserved.
 * See the LICENSE file for details.
 * SPDX-License-Identifier: (BSD-3-Clause)
 */

#pragma once

// Source includes
#include "LvArrayConfig.hpp"
#include "Macros.hpp"

// System includes
#include <cmath>
#include <type_traits>

namespace LvArray
{

namespace math
{


template< typename T >
LVARRAY_HOST_DEVICE inline constexpr
std::enable_if_t< std::is_arithmetic< T >::value, T >
max( T const a, T const b )
{
#if defined(__CUDA_ARCH__)
  static_assert( std::is_same< decltype( ::max( a, b ) ), T >::value, "Should return a T." );
  return ::max( a, b );
#else
  return std::max( a, b );
#endif
}

template< typename T >
LVARRAY_HOST_DEVICE inline constexpr
std::enable_if_t< std::is_arithmetic< T >::value, T >
min( T const a, T const b )
{
#if defined(__CUDA_ARCH__)
  static_assert( std::is_same< decltype( ::min( a, b ) ), T >::value, "Should return a T." );
  return ::min( a, b );
#else
  return std::min( a, b );
#endif
}

LVARRAY_HOST_DEVICE inline
float abs( float const x )
{ return ::fabsf( x ); }

LVARRAY_HOST_DEVICE inline
double abs( double const x )
{ return ::fabs( x ); }

template< typename T >
LVARRAY_HOST_DEVICE inline
std::enable_if_t< std::is_integral< T >::value, T >
abs( T const x )
{
#if defined(__CUDA_ARCH__)
  static_assert( std::is_same< decltype( ::abs( x ) ), T >::value, "Should return a T." );
  return ::abs( x );
#else
  static_assert( std::is_same< decltype( std::abs( x ) ), T >::value, "Should return a T." );
  return std::abs( x );
#endif
}



LVARRAY_HOST_DEVICE inline
float sqrt( float const x )
{ return ::sqrtf( x ); }

template< typename T >
LVARRAY_HOST_DEVICE inline
std::enable_if_t< std::is_arithmetic< T >::value, double >
sqrt( T const x )
{
#if defined(__CUDA_ARCH__)
  return ::sqrt( double( x ) );
#else
  return std::sqrt( x );
#endif
}

LVARRAY_HOST_DEVICE inline
float invSqrt( float const x )
{
#if defined(__CUDA_ARCH__)
  return ::rsqrtf( x );
#else
  return 1 / std::sqrt( x );
#endif
}

template< typename T >
LVARRAY_HOST_DEVICE inline
std::enable_if_t< std::is_arithmetic< T >::value, double >
invSqrt( T const x )
{
#if defined(__CUDACC__)
  return ::rsqrt( double( x ) );
#else
  return 1 / std::sqrt( x );
#endif
}



LVARRAY_HOST_DEVICE inline
float sin( float const theta )
{ return ::sinf( theta ); }

LVARRAY_HOST_DEVICE inline
double sin( double const theta )
{ return ::sin( theta ); }

LVARRAY_HOST_DEVICE inline
float cos( float const theta )
{ return ::cosf( theta ); }

LVARRAY_HOST_DEVICE inline
double cos( double const theta )
{ return ::cos( theta ); }

LVARRAY_HOST_DEVICE inline
float tan( float const theta )
{ return ::tanf( theta ); }

LVARRAY_HOST_DEVICE inline
double tan( double const theta )
{ return ::tan( theta ); }

LVARRAY_HOST_DEVICE inline
void sincos( float const theta, float & sinTheta, float & cosTheta )
{
#if defined(__CUDACC__)
  ::sincosf( theta, &sinTheta, &cosTheta );
#else
  sinTheta = ::sin( theta );
  cosTheta = ::cos( theta );
#endif
}

LVARRAY_HOST_DEVICE inline
void sincos( double const theta, double & sinTheta, double & cosTheta )
{
#if defined(__CUDACC__)
  ::sincos( theta, &sinTheta, &cosTheta );
#else
  sinTheta = ::sin( theta );
  cosTheta = ::cos( theta );
#endif
}



LVARRAY_HOST_DEVICE inline
float asin( float const x )
{ return ::asinf( x ); }

LVARRAY_HOST_DEVICE inline
double asin( double const x )
{ return ::asin( x ); }

LVARRAY_HOST_DEVICE inline
float acos( float const x )
{ return ::acosf( x ); }

LVARRAY_HOST_DEVICE inline
double acos( double const x )
{ return ::acos( x ); }

LVARRAY_HOST_DEVICE inline
float atan2( float const y, float const x )
{ return ::atan2f( y, x ); }

LVARRAY_HOST_DEVICE inline
double atan2( double const y, double const x )
{ return ::atan2( y, x ); }


} // namespace math
} // namespace LvArray