#include <cmath>
#include <limits>

Classes
struct	utl::Polynomial< Float, Tag, order >

struct	utl::Horner< Float, Tag, order >

struct	utl::Horner< Float, Tag, 0 >

class	utl::BranchPoint

class	utl::AsymptoticPolynomialB< order >

class	utl::AsymptoticPolynomialA

struct	utl::LogRecursionImpl< Float, branch, order >

struct	utl::LogRecursionImpl< Float, branch, 0 >

class	utl::Branch< Float, branch >

struct	utl::Iterator< Float, IterationStep >

struct	utl::Iterator< Float, IterationStep >::Depth< n, class >

struct	utl::Iterator< Float, IterationStep >::Depth< 1, T >

struct	utl::Iterator< Float, IterationStep >::Depth< 0, T >

struct	utl::Pade< Float, branch, n >

struct	utl::Pade< Float, 0, 1 >

struct	utl::Pade< Float, 0, 2 >

struct	utl::Pade< Float, -1, 4 >

struct	utl::Pade< Float, -1, 5 >

struct	utl::Pade< Float, -1, 6 >

struct	utl::Pade< Float, -1, 7 >

Namespaces
namespace	utl

Macros
#define	HORNER_COEFF(_Tag_, _i_, _c_) template<typename Float> struct Polynomial<Float, _Tag_, _i_> { static Float Coeff() { return Float(_c_); } }

#define	HORNER_COEFF2(_Tag_, _i_, _c_y_) template<typename Float> struct Polynomial<Float, _Tag_, _i_> { static Float Coeff(const Float y) { return Float(_c_y_); } }

#define	HORNER0(F, x, c0) (F)(c0)

#define	HORNER1(F, x, c1, c0) HORNER0(F, x, (F)(c1)*(x) + (F)(c0) )

#define	HORNER2(F, x, c2, c1, c0) HORNER1(F, x, (F)(c2)*(x) + (F)(c1), c0)

#define	HORNER3(F, x, c3, c2, c1, c0) HORNER2(F, x, (F)(c3)*(x) + (F)(c2), c1, c0)

#define	HORNER4(F, x, c4, c3, c2, c1, c0) HORNER3(F, x, (F)(c4)*(x) + (F)(c3), c2, c1, c0)

#define	HORNER5(F, x, c5, c4, c3, c2, c1, c0) HORNER4(F, x, (F)(c5)*(x) + (F)(c4), c3, c2, c1, c0)

#define	HORNER6(F, x, c6, c5, c4, c3, c2, c1, c0) HORNER5(F, x, (F)(c6)*(x) + (F)(c5), c4, c3, c2, c1, c0)

#define	HORNER7(F, x, c7, c6, c5, c4, c3, c2, c1, c0) HORNER6(F, x, (F)(c7)*(x) + (F)(c6), c5, c4, c3, c2, c1, c0)

#define	HORNER8(F, x, c8, c7, c6, c5, c4, c3, c2, c1, c0) HORNER7(F, x, (F)(c8)*(x) + (F)(c7), c6, c5, c4, c3, c2, c1, c0)

#define	HORNER9(F, x, c9, c8, c7, c6, c5, c4, c3, c2, c1, c0) HORNER8(F, x, (F)(c9)*(x) + (F)(c8), c7, c6, c5, c4, c3, c2, c1, c0)

#define	Y2(d1, c12, d2) ((c12) ? (d1) : (d2))

#define	Y3(d1, c12, d2, c23, d3) Y2(Y2(d1, c12, d2), c23, d3)

#define	Y4(d1, c12, d2, c23, d3, c34, d4) Y3(d1, c12, d2, c23, Y2(d3, c34, d4))

#define	Y5(d1, c12, d2, c23, d3, c34, d4, c45, d5) Y4(Y2(d1, c12, d2), c23, d3, c34, d4, c45, d5)

#define	Y6(d1, c12, d2, c23, d3, c34, d4, c45, d5, c56, d6) Y5(d1, c12, d2, c23, d3, c34, d4, c45, Y2(d5, c56, d6))

#define	Y7(d1, c12, d2, c23, d3, c34, d4, c45, d5, c56, d6, c67, d7) Y6(d1, c12, d2, c23, Y2(d3, c34, d4), c45, d5, c56, d6, c67, d7)

Functions
	utl::HORNER_COEFF (BranchPoint, 0, -1)

	utl::HORNER_COEFF (BranchPoint, 1, 1)

	utl::HORNER_COEFF (BranchPoint, 2, -0.333333333333333333e0)

	utl::HORNER_COEFF (BranchPoint, 3, 0.152777777777777777e0)

	utl::HORNER_COEFF (BranchPoint, 4, -0.79629629629629630e-1)

	utl::HORNER_COEFF (BranchPoint, 5, 0.44502314814814814e-1)

	utl::HORNER_COEFF (BranchPoint, 6, -0.25984714873603760e-1)

	utl::HORNER_COEFF (BranchPoint, 7, 0.15635632532333920e-1)

	utl::HORNER_COEFF (BranchPoint, 8, -0.96168920242994320e-2)

	utl::HORNER_COEFF (BranchPoint, 9, 0.60145432529561180e-2)

	utl::HORNER_COEFF (BranchPoint, 10, -0.38112980348919993e-2)

	utl::HORNER_COEFF (BranchPoint, 11, 0.24408779911439826e-2)

	utl::HORNER_COEFF (BranchPoint, 12, -0.15769303446867841e-2)

	utl::HORNER_COEFF (BranchPoint, 13, 0.10262633205076071e-2)

	utl::HORNER_COEFF (BranchPoint, 14, -0.67206163115613620e-3)

	utl::HORNER_COEFF (BranchPoint, 15, 0.44247306181462090e-3)

	utl::HORNER_COEFF (BranchPoint, 16, -0.29267722472962746e-3)

	utl::HORNER_COEFF (BranchPoint, 17, 0.19438727605453930e-3)

	utl::HORNER_COEFF (BranchPoint, 18, -0.12957426685274883e-3)

	utl::HORNER_COEFF (BranchPoint, 19, 0.86650358052081260e-4)

	utl::HORNER_COEFF (AsymptoticPolynomialB< 2 >, 0, 0)

	utl::HORNER_COEFF (AsymptoticPolynomialB< 2 >, 1, -1)

	utl::HORNER_COEFF (AsymptoticPolynomialB< 2 >, 2, 1./2)

	utl::HORNER_COEFF (AsymptoticPolynomialB< 3 >, 0, 0)

	utl::HORNER_COEFF (AsymptoticPolynomialB< 3 >, 1, 1)

	utl::HORNER_COEFF (AsymptoticPolynomialB< 3 >, 2, -3./2)

	utl::HORNER_COEFF (AsymptoticPolynomialB< 3 >, 3, 1./3)

	utl::HORNER_COEFF (AsymptoticPolynomialB< 4 >, 0, 0)

	utl::HORNER_COEFF (AsymptoticPolynomialB< 4 >, 1, -1)

	utl::HORNER_COEFF (AsymptoticPolynomialB< 4 >, 2, 3)

	utl::HORNER_COEFF (AsymptoticPolynomialB< 4 >, 3, -11./6)

	utl::HORNER_COEFF (AsymptoticPolynomialB< 4 >, 4, 1./4)

	utl::HORNER_COEFF (AsymptoticPolynomialB< 5 >, 0, 0)

	utl::HORNER_COEFF (AsymptoticPolynomialB< 5 >, 1, 1)

	utl::HORNER_COEFF (AsymptoticPolynomialB< 5 >, 2, -5)

	utl::HORNER_COEFF (AsymptoticPolynomialB< 5 >, 3, 35./6)

	utl::HORNER_COEFF (AsymptoticPolynomialB< 5 >, 4, -25./12)

	utl::HORNER_COEFF (AsymptoticPolynomialB< 5 >, 5, 1./5)

	utl::HORNER_COEFF2 (AsymptoticPolynomialA, 0, -y)

	utl::HORNER_COEFF2 (AsymptoticPolynomialA, 1, y)

	utl::HORNER_COEFF2 (AsymptoticPolynomialA, 2,(Horner< Float, AsymptoticPolynomialB< 2 >, 2 >::Eval(y)))

	utl::HORNER_COEFF2 (AsymptoticPolynomialA, 3,(Horner< Float, AsymptoticPolynomialB< 3 >, 3 >::Eval(y)))

	utl::HORNER_COEFF2 (AsymptoticPolynomialA, 4,(Horner< Float, AsymptoticPolynomialB< 4 >, 4 >::Eval(y)))

	utl::HORNER_COEFF2 (AsymptoticPolynomialA, 5,(Horner< Float, AsymptoticPolynomialB< 5 >, 5 >::Eval(y)))

template<typename Float , int order>
Float	utl::AsymptoticExpansionImpl (const Float a, const Float b)

template<typename Float >
Float	utl::HalleyStep (const Float x, const Float w)

template<typename Float >
Float	utl::FritschStep (const Float x, const Float w)

template<typename Float >
Float	utl::SchroederStep (const Float x, const Float w)

template<int branch>
double	utl::LambertW (const double x)

template<>
double	utl::LambertW< 0 > (const double x)

template<>
double	utl::LambertW<-1 > (const double x)

double	utl::LambertW (const int branch, const double x)

Macro Definition Documentation

◆ HORNER_COEFF

#define HORNER_COEFF	(	_Tag_,
		_i_,
		_c_ ) template<typename Float> struct Polynomial<Float, _Tag_, _i_> { static Float Coeff() { return Float(_c_); } }

Definition at line 62 of file LambertW.hh.

62#define HORNER_COEFF(_Tag_, _i_, _c_) \

63 template<typename Float> struct Polynomial<Float, _Tag_, _i_> { static Float Coeff() { return Float(_c_); } }

◆ HORNER_COEFF2

#define HORNER_COEFF2	(	_Tag_,
		_i_,
		_c_y_ ) template<typename Float> struct Polynomial<Float, _Tag_, _i_> { static Float Coeff(const Float y) { return Float(_c_y_); } }

Definition at line 64 of file LambertW.hh.

64#define HORNER_COEFF2(_Tag_, _i_, _c_y_) \

65 template<typename Float> struct Polynomial<Float, _Tag_, _i_> { static Float Coeff(const Float y) { return Float(_c_y_); } }

◆ HORNER0

#define HORNER0	(	F,
		x,
		c0 ) (F)(c0)

Definition at line 68 of file LambertW.hh.

◆ HORNER1

#define HORNER1	(	F,
		x,
		c1,
		c0 ) HORNER0(F, x, (F)(c1)*(x) + (F)(c0) )

Definition at line 69 of file LambertW.hh.

◆ HORNER2

#define HORNER2	(	F,
		x,
		c2,
		c1,
		c0 ) HORNER1(F, x, (F)(c2)*(x) + (F)(c1), c0)

Definition at line 70 of file LambertW.hh.

◆ HORNER3

#define HORNER3	(	F,
		x,
		c3,
		c2,
		c1,
		c0 ) HORNER2(F, x, (F)(c3)*(x) + (F)(c2), c1, c0)

Definition at line 71 of file LambertW.hh.

◆ HORNER4

#define HORNER4	(	F,
		x,
		c4,
		c3,
		c2,
		c1,
		c0 ) HORNER3(F, x, (F)(c4)*(x) + (F)(c3), c2, c1, c0)

Definition at line 72 of file LambertW.hh.

◆ HORNER5

#define HORNER5	(	F,
		x,
		c5,
		c4,
		c3,
		c2,
		c1,
		c0 ) HORNER4(F, x, (F)(c5)*(x) + (F)(c4), c3, c2, c1, c0)

Definition at line 73 of file LambertW.hh.

◆ HORNER6

#define HORNER6	(	F,
		x,
		c6,
		c5,
		c4,
		c3,
		c2,
		c1,
		c0 ) HORNER5(F, x, (F)(c6)*(x) + (F)(c5), c4, c3, c2, c1, c0)

Definition at line 74 of file LambertW.hh.

◆ HORNER7

#define HORNER7	(	F,
		x,
		c7,
		c6,
		c5,
		c4,
		c3,
		c2,
		c1,
		c0 ) HORNER6(F, x, (F)(c7)*(x) + (F)(c6), c5, c4, c3, c2, c1, c0)

Definition at line 75 of file LambertW.hh.

◆ HORNER8

#define HORNER8	(	F,
		x,
		c8,
		c7,
		c6,
		c5,
		c4,
		c3,
		c2,
		c1,
		c0 ) HORNER7(F, x, (F)(c8)*(x) + (F)(c7), c6, c5, c4, c3, c2, c1, c0)

Definition at line 76 of file LambertW.hh.

◆ HORNER9

#define HORNER9	(	F,
		x,
		c9,
		c8,
		c7,
		c6,
		c5,
		c4,
		c3,
		c2,
		c1,
		c0 ) HORNER8(F, x, (F)(c9)*(x) + (F)(c8), c7, c6, c5, c4, c3, c2, c1, c0)

Definition at line 77 of file LambertW.hh.

◆ Y2

#define Y2	(	d1,
		c12,
		d2 ) ((c12) ? (d1) : (d2))

Definition at line 82 of file LambertW.hh.

82#define Y2(d1, c12, d2) \

83 ((c12) ? (d1) : (d2))

◆ Y3

#define Y3	(	d1,
		c12,
		d2,
		c23,
		d3 ) Y2(Y2(d1, c12, d2), c23, d3)

Definition at line 84 of file LambertW.hh.

84#define Y3(d1, c12, d2, c23, d3) \

85 Y2(Y2(d1, c12, d2), c23, d3)

◆ Y4

#define Y4	(	d1,
		c12,
		d2,
		c23,
		d3,
		c34,
		d4 ) Y3(d1, c12, d2, c23, Y2(d3, c34, d4))

Definition at line 86 of file LambertW.hh.

86#define Y4(d1, c12, d2, c23, d3, c34, d4) \

87 Y3(d1, c12, d2, c23, Y2(d3, c34, d4))

◆ Y5

#define Y5	(	d1,
		c12,
		d2,
		c23,
		d3,
		c34,
		d4,
		c45,
		d5 ) Y4(Y2(d1, c12, d2), c23, d3, c34, d4, c45, d5)

Definition at line 88 of file LambertW.hh.

88#define Y5(d1, c12, d2, c23, d3, c34, d4, c45, d5) \

89 Y4(Y2(d1, c12, d2), c23, d3, c34, d4, c45, d5)

◆ Y6

#define Y6	(	d1,
		c12,
		d2,
		c23,
		d3,
		c34,
		d4,
		c45,
		d5,
		c56,
		d6 ) Y5(d1, c12, d2, c23, d3, c34, d4, c45, Y2(d5, c56, d6))

Definition at line 90 of file LambertW.hh.

90#define Y6(d1, c12, d2, c23, d3, c34, d4, c45, d5, c56, d6) \

91 Y5(d1, c12, d2, c23, d3, c34, d4, c45, Y2(d5, c56, d6))

◆ Y7

#define Y7	(	d1,
		c12,
		d2,
		c23,
		d3,
		c34,
		d4,
		c45,
		d5,
		c56,
		d6,
		c67,
		d7 ) Y6(d1, c12, d2, c23, Y2(d3, c34, d4), c45, d5, c56, d6, c67, d7)

Definition at line 92 of file LambertW.hh.

92#define Y7(d1, c12, d2, c23, d3, c34, d4, c45, d5, c56, d6, c67, d7) \

93 Y6(d1, c12, d2, c23, Y2(d3, c34, d4), c45, d5, c56, d6, c67, d7)

Classes

Namespaces

Macros

Functions