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); }