PCL
Math.h File Reference
#include <pcl/Defs.h>
#include <pcl/Diagnostics.h>
#include <pcl/Memory.h>
#include <pcl/Selection.h>
#include <pcl/Sort.h>
#include <pcl/Utility.h>
#include <cmath>
#include <cstdlib>
#include <limits>

Go to the source code of this file.

Classes

class  pcl::Fact< T >
 Factorial function. More...
 
class  pcl::Pow10I< T >
 Exponential function 10**n, n being a signed integer. More...
 
class  pcl::Pow2I< T >
 Exponential function 2**n, n being a signed integer. More...
 

Namespaces

 pcl
 PCL root namespace.
 

Functions

float pcl::Abs (float x)
 
template<typename T >
constexpr T pcl::Angle (int d, T m)
 
template<typename T >
constexpr T pcl::Angle (int d, int m, T s)
 
template<typename T >
constexpr T pcl::ArcCos (T x)
 
template<typename T >
constexpr T pcl::ArcCosh (T x)
 
template<typename T >
constexpr T pcl::ArcHav (T x)
 
template<typename T >
constexpr T pcl::ArcSin (T x)
 
template<typename T >
constexpr T pcl::ArcSinh (T x)
 
template<typename T >
constexpr T pcl::ArcTan (T x)
 
template<typename T >
constexpr T pcl::ArcTan (T y, T x)
 
template<typename T >
pcl::ArcTan2Pi (T y, T x)
 
template<typename T >
constexpr T pcl::ArcTanh (T x)
 
template<typename T >
constexpr T pcl::AsRad (T x)
 
template<typename T >
double pcl::AvgDev (const T *i, const T *j, double center)
 
template<typename T >
double pcl::AvgDev (const T *i, const T *j)
 
template<typename T >
double pcl::BendMidvariance (const T *x, const T *xn, double center, double beta=0.2)
 
template<typename T >
double pcl::BiweightMidvariance (const T *x, const T *xn, double center, double sigma, int k=9)
 
template<typename T >
constexpr T pcl::Ceil (T x)
 
void PCL_FUNC pcl::ComplexTimeToJD (int &jdi, double &jdf, int year, int month, int day, double dayf=0)
 
double pcl::ComplexTimeToJD (int year, int month, int day, double dayf=0)
 
template<typename T >
constexpr T pcl::Cos (T x)
 
template<typename T >
constexpr T pcl::Cosh (T x)
 
template<typename T >
constexpr T pcl::Cotan (T x)
 
template<typename S1 , typename S2 , typename S3 , typename D >
void pcl::DecimalToSexagesimal (int &sign, S1 &s1, S2 &s2, S3 &s3, const D &d)
 
template<typename T >
constexpr T pcl::Deg (T x)
 
template<typename T >
constexpr T pcl::Exp (T x)
 
template<typename T >
constexpr T pcl::Floor (T x)
 
template<typename T >
constexpr T pcl::Frac (T x)
 
template<typename T >
void pcl::Frexp (T x, T &m, int &p)
 
uint32 pcl::Hash32 (const void *data, size_type size, uint32 seed=0)
 
uint64 pcl::Hash64 (const void *data, size_type size, uint64 seed=0)
 
template<typename T >
constexpr T pcl::Hav (T x)
 
bool pcl::IsFinite (float x)
 
bool pcl::IsFinite (double x)
 
int pcl::IsInfinity (float x)
 
int pcl::IsInfinity (double x)
 
bool pcl::IsNaN (float x)
 
bool pcl::IsNaN (double x)
 
void PCL_FUNC pcl::JDToComplexTime (int &year, int &month, int &day, double &dayf, int jdi, double jdf)
 
void pcl::JDToComplexTime (int &year, int &month, int &day, double &dayf, double jd)
 
template<typename T >
double pcl::L1Norm (const T *i, const T *j)
 
template<typename T >
double pcl::L2Norm (const T *i, const T *j)
 
template<typename T >
constexpr T pcl::Ldexp (T m, int p)
 
template<typename T >
constexpr T pcl::Ln (T x)
 
constexpr long double pcl::Ln2 ()
 
template<typename T >
constexpr T pcl::Log (T x)
 
constexpr long double pcl::Log2 ()
 
template<typename T >
constexpr T pcl::Log2 (T x)
 
constexpr long double pcl::Log2e ()
 
constexpr long double pcl::Log2T ()
 
template<typename T >
constexpr T pcl::LogN (T n, T x)
 
template<typename T >
double pcl::MAD (const T *i, const T *j, double center)
 
template<typename T >
double pcl::MAD (const T *i, const T *j)
 
template<typename T >
constexpr T pcl::MasRad (T x)
 
int pcl::MaxSSEInstructionSetSupported ()
 
template<typename T >
double pcl::Mean (const T *i, const T *j)
 
template<typename T >
double pcl::Median (T *i, T *j)
 
template<typename T , class BP >
double pcl::Median (T *i, T *j, BP p)
 
template<typename T >
constexpr T pcl::MinRad (T x)
 
template<typename T >
constexpr T pcl::Mod (T x, T y)
 
template<typename T >
constexpr T pcl::Mod2Pi (T x)
 
template<typename T >
double pcl::Modulus (const T *i, const T *j)
 
template<typename T >
double pcl::NondestructiveMedian (const T *i, const T *j)
 
template<typename T , class BP >
double pcl::NondestructiveMedian (const T *i, const T *j, BP p)
 
template<typename T >
double pcl::Norm (const T *i, const T *j, double p)
 
template<typename T >
double pcl::Norm (const T *i, const T *j)
 
template<typename T >
constexpr T pcl::Norm2Pi (T x)
 
constexpr long double pcl::Pi ()
 
template<typename T , typename C >
pcl::Poly (T x, C c, int n)
 
template<typename T >
pcl::Poly (T x, std::initializer_list< T > c)
 
template<typename T >
constexpr T pcl::Pow (T x, T y)
 
template<typename T >
pcl::Pow10 (T x)
 
template<typename T >
constexpr T pcl::Pow2 (T x)
 
template<typename T >
pcl::PowI (T x, int n)
 
template<typename T >
double pcl::Qn (T *x, T *xn)
 
template<typename T >
constexpr T pcl::Rad (T x)
 
template<typename T >
constexpr T pcl::RadMin (T x)
 
template<typename T >
constexpr T pcl::RadSec (T x)
 
template<typename T , typename T1 , typename T2 >
void pcl::Rotate (T &x, T &y, T1 sa, T1 ca, T2 xc, T2 yc)
 
template<typename T1 , typename T2 >
void pcl::Rotate (int &x, int &y, T1 sa, T1 ca, T2 xc, T2 yc)
 
template<typename T1 , typename T2 >
void pcl::Rotate (long &x, long &y, T1 sa, T1 ca, T2 xc, T2 yc)
 
template<typename T1 , typename T2 >
void pcl::Rotate (int64 &x, int64 &y, T1 sa, T1 ca, T2 xc, T2 yc)
 
template<typename T , typename T1 , typename T2 >
void pcl::Rotate (T &x, T &y, T1 a, T2 xc, T2 yc)
 
template<typename T >
pcl::RotL (T x, uint32 n)
 
template<typename T >
pcl::RotR (T x, uint32 n)
 
double pcl::Round (double x)
 
float pcl::Round (float x)
 
long double pcl::Round (long double x)
 
template<typename T >
pcl::Round (T x, int n)
 
template<typename T >
int pcl::RoundI (T x)
 
int64 pcl::RoundI64 (double x)
 
template<typename T >
int pcl::RoundInt (T x)
 
int64 pcl::RoundInt64 (double x)
 
int64 pcl::RoundInt64Arithmetic (double x)
 
template<typename T >
int pcl::RoundIntArithmetic (T x)
 
template<typename T >
int pcl::RoundIntBanker (T x)
 
template<typename T >
constexpr T pcl::SecRad (T x)
 
template<typename S1 , typename S2 , typename S3 >
double pcl::SexagesimalToDecimal (int sign, const S1 &s1, const S2 &s2=S2(0), const S3 &s3=S3(0))
 
template<typename T >
constexpr int pcl::Sign (T x)
 
template<typename T >
constexpr char pcl::SignChar (T x)
 
template<typename T >
constexpr T pcl::Sin (T x)
 
template<typename T >
void pcl::SinCos (T x, T &sx, T &cx)
 
template<typename T >
constexpr T pcl::Sinh (T x)
 
template<typename T >
double pcl::Sn (T *x, T *xn)
 
template<typename T >
void pcl::Split (T x, T &i, T &f)
 
template<typename T >
constexpr T pcl::Sqrt (T x)
 
template<typename T >
double pcl::StableAvgDev (const T *i, const T *j, double center)
 
template<typename T >
double pcl::StableAvgDev (const T *i, const T *j)
 
template<typename T >
double pcl::StableMean (const T *i, const T *j)
 
template<typename T >
double pcl::StableModulus (const T *i, const T *j)
 
template<typename T >
double pcl::StableSum (const T *i, const T *j)
 
template<typename T >
double pcl::StableSumOfSquares (const T *i, const T *j)
 
template<typename T >
double pcl::StdDev (const T *i, const T *j, double center)
 
template<typename T >
double pcl::StdDev (const T *i, const T *j)
 
template<typename T >
double pcl::Sum (const T *i, const T *j)
 
template<typename T >
double pcl::SumOfSquares (const T *i, const T *j)
 
template<typename T >
constexpr T pcl::Tan (T x)
 
template<typename T >
constexpr T pcl::Tanh (T x)
 
template<typename T >
pcl::Trunc (T x)
 
template<typename T >
int pcl::TruncI (T x)
 
template<typename T >
int64 pcl::TruncI64 (T x)
 
template<typename T >
int pcl::TruncInt (T x)
 
template<typename T >
int64 pcl::TruncInt64 (T x)
 
constexpr long double pcl::TwoPi ()
 
template<typename T >
constexpr T pcl::UasRad (T x)
 
template<typename T >
double pcl::Variance (const T *i, const T *j, double center)
 
template<typename T >
double pcl::Variance (const T *i, const T *j)