inline GAUSS gauss_ini(double e, double phi0, double &chi, double &rc)
{
using std::asin;
using std::cos;
using std::sin;
using std::sqrt;
using std::tan;
double sphi = 0;
double cphi = 0;
double es = 0;
GAUSS en;
es = e * e;
en.e = e;
sphi = sin(phi0);
cphi = cos(phi0);
cphi *= cphi;
rc = sqrt(1.0 - es) / (1.0 - es * sphi * sphi);
en.C = sqrt(1.0 + es * cphi * cphi / (1.0 - es));
chi = asin(sphi / en.C);
en.ratexp = 0.5 * en.C * e;
en.K = tan(0.5 * chi + detail::FORTPI)
/ (pow(tan(0.5 * phi0 + detail::FORTPI), en.C) * srat(en.e * sphi, en.ratexp));
return en;
}
TEST(AgradFwdTan, FvarFvarVar_2ndDeriv) {
using stan::agrad::fvar;
using stan::agrad::var;
using std::tan;
using std::cos;
fvar<fvar<var> > x;
x.val_.val_ = 1.5;
x.val_.d_ = 2.0;
fvar<fvar<var> > a = tan(x);
AVEC p = createAVEC(x.val_.val_);
VEC g;
a.val_.d_.grad(p,g);
EXPECT_FLOAT_EQ(2.0 * 2.0 * tan(1.5) / (cos(1.5) * cos(1.5)), g[0]);
fvar<fvar<var> > y;
y.val_.val_ = 1.5;
y.d_.val_ = 2.0;
fvar<fvar<var> > b = tan(y);
AVEC q = createAVEC(y.val_.val_);
VEC r;
b.d_.val_.grad(q,r);
EXPECT_FLOAT_EQ(2.0 * 2.0 * tan(1.5) / (cos(1.5) * cos(1.5)), r[0]);
}
TEST(AgradFwdTan, FvarFvarDouble) {
using stan::agrad::fvar;
using std::tan;
using std::cos;
fvar<fvar<double> > x;
x.val_.val_ = 1.5;
x.val_.d_ = 2.0;
fvar<fvar<double> > a = tan(x);
EXPECT_FLOAT_EQ(tan(1.5), a.val_.val_);
EXPECT_FLOAT_EQ(2.0 / (cos(1.5) * cos(1.5)), a.val_.d_);
EXPECT_FLOAT_EQ(0, a.d_.val_);
EXPECT_FLOAT_EQ(0, a.d_.d_);
fvar<fvar<double> > y;
y.val_.val_ = 1.5;
y.d_.val_ = 2.0;
a = tan(y);
EXPECT_FLOAT_EQ(tan(1.5), a.val_.val_);
EXPECT_FLOAT_EQ(0, a.val_.d_);
EXPECT_FLOAT_EQ(2.0 / (cos(1.5) * cos(1.5)), a.d_.val_);
EXPECT_FLOAT_EQ(0, a.d_.d_);
}
TEST(AgradFwdTan, FvarVar_2ndDeriv) {
using stan::agrad::fvar;
using stan::agrad::var;
using std::tan;
using std::cos;
fvar<var> x(1.5,1.3);
fvar<var> a = tan(x);
AVEC y = createAVEC(x.val_);
VEC g;
a.d_.grad(y,g);
EXPECT_FLOAT_EQ(2.0 / (cos(1.5) * cos(1.5)) * tan(1.5) * 1.3, g[0]);
}
//! Compute pressure coefficient using the Hankey flat surface method.
double computeHankeyFlatSurfacePressureCoefficient(
double inclinationAngle, double machNumber )
{
// Declare local variables.
double stagnationPressureCoefficient_;
// Calculate 'effective' stagnation pressure coefficient for low
// inclination angle.
if( inclinationAngle < PI / 18.0 )
{
stagnationPressureCoefficient_ = ( 0.195 + 0.222594 / pow( machNumber, 0.3 ) - 0.4 )
* inclinationAngle * 180.0 / PI + 4.0;
}
// Calculate 'effective' stagnation pressure coefficient for other
// inclination angle.
else
{
stagnationPressureCoefficient_ = 1.95 + 0.3925 / ( pow( machNumber, 0.3 )
* tan( inclinationAngle ) );
}
// Return pressure coefficient using 'effective' stagnation pressure
// coefficient.
return computeModifiedNewtonianPressureCoefficient(
inclinationAngle, stagnationPressureCoefficient_ );
}
inline
fvar<T>
tan(const fvar<T>& x) {
using std::cos;
using std::tan;
return fvar<T>(tan(x.val_), x.d_ / (cos(x.val_) * cos(x.val_)));
}
inline void gauss(GAUSS const& en, T& lam, T& phi)
{
phi = 2.0 * atan(en.K * pow(tan(0.5 * phi + FORTPI), en.C)
* srat(en.e * sin(phi), en.ratexp) ) - HALFPI;
lam *= en.C;
}
result_type operator()(Engine& eng)
{
// Can we have a boost::mathconst please?
const result_type pi = result_type(3.14159265358979323846);
#ifndef BOOST_NO_STDC_NAMESPACE
using std::tan;
#endif
return _median + _sigma * tan(pi*(eng()-result_type(0.5)));
}
void complex_number_examples()
{
Complex z1{0, 1};
std::cout << std::setprecision(std::numeric_limits<typename Complex::value_type>::digits10);
std::cout << std::scientific << std::fixed;
std::cout << "Print a complex number: " << z1 << std::endl;
std::cout << "Square it : " << z1*z1 << std::endl;
std::cout << "Real part : " << z1.real() << " = " << real(z1) << std::endl;
std::cout << "Imaginary part : " << z1.imag() << " = " << imag(z1) << std::endl;
using std::abs;
std::cout << "Absolute value : " << abs(z1) << std::endl;
std::cout << "Argument : " << arg(z1) << std::endl;
std::cout << "Norm : " << norm(z1) << std::endl;
std::cout << "Complex conjugate : " << conj(z1) << std::endl;
std::cout << "Projection onto Riemann sphere: " << proj(z1) << std::endl;
typename Complex::value_type r = 1;
typename Complex::value_type theta = 0.8;
using std::polar;
std::cout << "Polar coordinates (phase = 0) : " << polar(r) << std::endl;
std::cout << "Polar coordinates (phase !=0) : " << polar(r, theta) << std::endl;
std::cout << "\nElementary special functions:\n";
using std::exp;
std::cout << "exp(z1) = " << exp(z1) << std::endl;
using std::log;
std::cout << "log(z1) = " << log(z1) << std::endl;
using std::log10;
std::cout << "log10(z1) = " << log10(z1) << std::endl;
using std::pow;
std::cout << "pow(z1, z1) = " << pow(z1, z1) << std::endl;
using std::sqrt;
std::cout << "Take its square root : " << sqrt(z1) << std::endl;
using std::sin;
std::cout << "sin(z1) = " << sin(z1) << std::endl;
using std::cos;
std::cout << "cos(z1) = " << cos(z1) << std::endl;
using std::tan;
std::cout << "tan(z1) = " << tan(z1) << std::endl;
using std::asin;
std::cout << "asin(z1) = " << asin(z1) << std::endl;
using std::acos;
std::cout << "acos(z1) = " << acos(z1) << std::endl;
using std::atan;
std::cout << "atan(z1) = " << atan(z1) << std::endl;
using std::sinh;
std::cout << "sinh(z1) = " << sinh(z1) << std::endl;
using std::cosh;
std::cout << "cosh(z1) = " << cosh(z1) << std::endl;
using std::tanh;
std::cout << "tanh(z1) = " << tanh(z1) << std::endl;
using std::asinh;
std::cout << "asinh(z1) = " << asinh(z1) << std::endl;
using std::acosh;
std::cout << "acosh(z1) = " << acosh(z1) << std::endl;
using std::atanh;
std::cout << "atanh(z1) = " << atanh(z1) << std::endl;
}
// Convert geographic coordinates (latitude, longitude in degrees) into
// cartesian coordinates (in kilometers) using the Lambert 93 projection.
pair<float,float> geoToLambert93(float latitude,float longitude)
{
float phi = degreeToRadian(latitude);
float l = degreeToRadian(longitude);
float gl = log(tan(M_PI/4+phi/2)*pow((1-e*sin(phi))/(1+e*sin(phi)),e/2));
float x93 = X0 + c*exp(-n*gl)*sin(n*(l-lc));
float y93 = ys - c*exp(-n*gl)*cos(n*(l-lc));
return make_pair(x93/1000,y93/1000);
}
inline double invcdf_hcauchy(double p, double sigma,
bool& throw_warning) {
#ifdef IEEE_754
if (ISNAN(p) || ISNAN(sigma))
return p+sigma;
#endif
if (sigma <= 0.0 || !VALID_PROB(p)) {
throw_warning = true;
return NAN;
}
return sigma * tan((M_PI*p)/2.0);
}
//! Compute shock deflection angle.
double computeShockDeflectionAngle( double shockAngle, double machNumber,
double ratioOfSpecificHeats )
{
// Declare local variables.
double tangentOfDeflectionAngle_;
// Calculate tangent of deflection angle.
tangentOfDeflectionAngle_ = 2.0 * ( pow( machNumber * sin( shockAngle ), 2.0 ) - 1.0 )
/ ( tan( shockAngle ) * ( pow( machNumber, 2.0 )
* ( ratioOfSpecificHeats
+ cos( 2.0 * shockAngle ) ) + 2.0 ) );
// Return deflection angle.
return atan( tangentOfDeflectionAngle_ );
}
TEST(AgradFwdTan, FvarFvarVar_3rdDeriv) {
using stan::agrad::fvar;
using stan::agrad::var;
using std::tan;
using std::cos;
fvar<fvar<var> > x;
x.val_.val_ = 1.5;
x.val_.d_ = 1.0;
x.d_.val_ = 1.0;
fvar<fvar<var> > a = tan(x);
AVEC p = createAVEC(x.val_.val_);
VEC g;
a.d_.d_.grad(p,g);
EXPECT_FLOAT_EQ(238840.84160534013669260979995, g[0]);
}
int vectester (Vector zerovec)
{
using std::abs;
using std::acos;
using std::asin;
using std::atan;
using std::floor;
using std::pow;
using std::sin;
using std::sqrt;
using std::tan;
typedef typename Vector::value_type Scalar;
Vector random_vec = zerovec;
Vector error_vec = zerovec;
std::srand(12345); // Fixed seed for reproduceability of failures
// Avoid divide by zero errors or acos(x>1) NaNs later
for (unsigned int i=0; i != random_vec.size(); ++i)
random_vec.raw_at(i) = .25 + (static_cast<Scalar>(std::rand())/RAND_MAX/2);
int returnval = 0;
one_test(2*random_vec - random_vec - random_vec);
one_test(3*random_vec - random_vec*3);
one_test((random_vec + random_vec)/2 - random_vec);
one_test(sqrt(random_vec) * sqrt(random_vec) - random_vec);
one_test(random_vec*random_vec - pow(random_vec,2));
one_test(sqrt(random_vec) - pow(random_vec,Scalar(.5)));
one_test(random_vec - sin(asin(random_vec)));
one_test(random_vec - tan(atan(random_vec)));
one_test(floor(random_vec / 2));
one_test(abs(random_vec) - random_vec);
return returnval;
}
result_type operator()(Engine& eng)
{
#ifndef BOOST_NO_STDC_NAMESPACE
// allow for Koenig lookup
using std::tan; using std::sqrt; using std::exp; using std::log;
using std::pow;
#endif
if(_alpha == result_type(1)) {
return _exp(eng);
} else if(_alpha > result_type(1)) {
// Can we have a boost::mathconst please?
const result_type pi = result_type(3.14159265358979323846);
for(;;) {
result_type y = tan(pi * eng());
result_type x = sqrt(result_type(2)*_alpha-result_type(1))*y
+ _alpha-result_type(1);
if(x <= result_type(0))
continue;
if(eng() >
(result_type(1)+y*y) * exp((_alpha-result_type(1))
*log(x/(_alpha-result_type(1)))
- sqrt(result_type(2)*_alpha
-result_type(1))*y))
continue;
return x;
}
} else /* alpha < 1.0 */ {
for(;;) {
result_type u = eng();
result_type y = _exp(eng);
result_type x, q;
if(u < _p) {
x = exp(-y/_alpha);
q = _p*exp(-x);
} else {
x = result_type(1)+y;
q = _p + (result_type(1)-_p) * pow(x, _alpha-result_type(1));
}
if(u >= q)
continue;
return x;
}
}
}
inline void inv_gauss(GAUSS const& en, T& lam, T& phi)
{
lam /= en.C;
const double num = pow(tan(0.5 * phi + FORTPI) / en.K, 1.0 / en.C);
int i = 0;
for (i = MAX_ITER; i; --i)
{
const double elp_phi = 2.0 * atan(num * srat(en.e * sin(phi), - 0.5 * en.e)) - HALFPI;
if (geometry::math::abs(elp_phi - phi) < DEL_TOL)
{
break;
}
phi = elp_phi;
}
/* convergence failed */
if (!i)
{
throw proj_exception(-17);
}
}
double tand(double d)
{
return tan(d/DEG_TO_RAD);
}
TEST(AgradFwdTan, Fvar) {
using stan::agrad::fvar;
using std::tan;
using std::cos;
fvar<double> x(0.5,1.0);
fvar<double> a = tan(x);
EXPECT_FLOAT_EQ(tan(0.5), a.val_);
EXPECT_FLOAT_EQ(1 / (cos(0.5) * cos(0.5)), a.d_);
fvar<double> b = 2 * tan(x) + 4;
EXPECT_FLOAT_EQ(2 * tan(0.5) + 4, b.val_);
EXPECT_FLOAT_EQ(2 / (cos(0.5) * cos(0.5)), b.d_);
fvar<double> c = -tan(x) + 5;
EXPECT_FLOAT_EQ(-tan(0.5) + 5, c.val_);
EXPECT_FLOAT_EQ(-1 / (cos(0.5) * cos(0.5)), c.d_);
fvar<double> d = -3 * tan(x) + 5 * x;
EXPECT_FLOAT_EQ(-3 * tan(0.5) + 5 * 0.5, d.val_);
EXPECT_FLOAT_EQ(-3 / (cos(0.5) * cos(0.5)) + 5, d.d_);
fvar<double> y(-0.5,1.0);
fvar<double> e = tan(y);
EXPECT_FLOAT_EQ(tan(-0.5), e.val_);
EXPECT_FLOAT_EQ(1 / (cos(-0.5) * cos(-0.5)), e.d_);
fvar<double> z(0.0,1.0);
fvar<double> f = tan(z);
EXPECT_FLOAT_EQ(tan(0.0), f.val_);
EXPECT_FLOAT_EQ(1 / (cos(0.0) * cos(0.0)), f.d_);
}
int vectester (Vector zerovec)
{
using std::abs;
using std::acos;
using std::asin;
using std::atan;
using std::ceil;
using std::cos;
using std::cosh;
using std::exp;
using std::fabs;
using std::floor;
using std::log;
using std::log10;
using std::pow;
using std::sin;
using std::sinh;
using std::sqrt;
using std::tan;
using std::tanh;
typedef typename ValueType<Vector>::type DualScalar;
typedef typename DualScalar::value_type Scalar;
Vector random_vec = zerovec;
typename DerivativeType<Vector>::type error_vec = 0;
std::srand(12345); // Fixed seed for reproduceability of failures
// Avoid divide by zero errors later
for (unsigned int i=0; i != N; ++i)
{
random_vec.raw_at(i) = .25 + (static_cast<Scalar>(std::rand())/RAND_MAX);
random_vec.raw_at(i).derivatives() = 1;
}
// Scalar pi = acos(Scalar(-1));
int returnval = 0;
// Running non-derivatives tests with DualNumbers sometimes catches
// problems too
one_test(2*random_vec - random_vec - random_vec);
one_test(3*random_vec - random_vec*3);
one_test((random_vec + random_vec)/2 - random_vec);
// We had a problem in user code with the mixing of long double and
// DualNumber<double, DynamicSparseNumberArray>
one_test(2.L*random_vec - random_vec - 1.f*random_vec);
// pow() is still having problems with sparse vectors? Disabling it
// for now.
one_test(sqrt(random_vec) * sqrt(random_vec) - random_vec);
// one_test(random_vec*random_vec - pow(random_vec,2));
// one_test(sqrt(random_vec) - pow(random_vec,Scalar(.5)));
// functions which map zero to non-zero are not defined for sparse
// vectors. This includes exp(), log(), cos(), cosh(),
// pow(scalar,sparse), scalar/sparse, sparse +/- scalar...
// one_test(log(exp(random_vec)) - random_vec);
// one_test(exp(log(random_vec)) - random_vec);
// one_test(exp(random_vec) - pow(exp(Scalar(1)), random_vec));
// one_test(tan(random_vec) - sin(random_vec)/cos(random_vec));
one_test(random_vec - sin(asin(random_vec)));
// one_test(random_vec - cos(acos(random_vec)));
one_test(random_vec - tan(atan(random_vec)));
// one_test(1 - pow(sin(random_vec), 2) - pow(cos(random_vec), 2));
// one_test(cos(random_vec) - sin(random_vec + pi/2));
// one_test(tanh(random_vec) - sinh(random_vec)/cosh(random_vec));
// one_test(1 + pow(sinh(random_vec), 2) - pow(cosh(random_vec), 2));
// one_test(log10(random_vec) - log(random_vec)/log(Scalar(10)));
one_test(floor(random_vec / 2));
// one_test(ceil(random_vec / 2 - 1));
one_test(abs(random_vec) - random_vec);
// one_test(fabs(random_vec-.75) - abs(random_vec-.75));
// And now for derivatives tests
// one_test(derivatives(pow(sin(random_vec-2),2)) -
// 2*sin(random_vec)*cos(random_vec));
// one_test(derivatives(cos(2*random_vec)) + 2*sin(2*random_vec));
// one_test(derivatives(tan(.5*random_vec)) - .5/pow(cos(.5*random_vec),2));
// one_test(derivatives(sqrt(random_vec+1)) - 1/sqrt(random_vec+1)/2);
// one_test(derivatives((random_vec-1)*(random_vec-1)) - 2*(random_vec-1));
// one_test(derivatives(pow(random_vec,1.5)) -
// 1.5*pow(random_vec,.5));
// one_test(derivatives(exp(pow(random_vec,3))) -
// exp(pow(random_vec,3))*3*pow(random_vec,2));
// one_test(derivatives(exp(random_vec)) -
// exp(random_vec));
// one_test(derivatives(pow(2,random_vec)) -
// pow(2,random_vec)*log(Scalar(2)));
// one_test(derivatives(asin(random_vec)) -
// 1/sqrt(1-random_vec*random_vec));
// one_test(derivatives(sinh(random_vec)) - cosh(random_vec));
// one_test(derivatives(cosh(random_vec)) - sinh(random_vec));
// one_test(derivatives(tanh(random_vec)) -
// derivatives(sinh(random_vec)/cosh(random_vec)));
return returnval;
}
inline T0
operator()(const T0& arg1) const {
return tan(arg1);
}
//
inline float degreeToRadian(float deg){ return deg/180*M_PI; }
const float a = 6378137; // semi-major axis of the ellipsoid
const float e = 0.08181919106; // first eccentricity of the ellipsoid
const float lc = degreeToRadian(3.f);
const float l0 = degreeToRadian(3.f);
const float phi1 = degreeToRadian(44.f); // 1st automecoic parallel
const float phi2 = degreeToRadian(49.f); // 2nd automecoic parallel
const float phi0 = degreeToRadian(46.5f);// latitude of origin
const float X0 = 700000; // x coordinate at origin
const float Y0 = 6600000; // y coordinate at origin
// Normals
const float gN1 = a/sqrt(1-e*e*sin(phi1)*sin(phi1));
const float gN2 = a/sqrt(1-e*e*sin(phi2)*sin(phi2));
// Isometric latitudes
const float gl1=log(tan(M_PI/4+phi1/2)*pow((1-e*sin(phi1))/(1+e*sin(phi1)),e/2));
const float gl2=log(tan(M_PI/4+phi2/2)*pow((1-e*sin(phi2))/(1+e*sin(phi2)),e/2));
const float gl0=log(tan(M_PI/4+phi0/2)*pow((1-e*sin(phi0))/(1+e*sin(phi0)),e/2));
// Projection exponent
const float n = (log((gN2*cos(phi2))/(gN1*cos(phi1))))/(gl1-gl2);
// Projection constant
const float c = ((gN1*cos(phi1))/n)*exp(n*gl1);
// Coordinate
const float ys = Y0 + c*exp(-n*gl0);
// Convert geographic coordinates (latitude, longitude in degrees) into
// cartesian coordinates (in kilometers) using the Lambert 93 projection.
pair<float,float> geoToLambert93(float latitude,float longitude)
{
float phi = degreeToRadian(latitude);
float l = degreeToRadian(longitude);
double my_tan(double x)
{
return 50. * tan(x);
}
