void DotTemplate::paintPage(QPainter *painter, const QRectF &rect) { const double step = mm(5); const double size = mm(m_dotSize); const double shiftX = (fmod(rect.width(), step) + step - size) / 2; const double shiftY = (fmod(rect.height(), step) + step - size) / 2; pagePen.setWidthF(mm(pagePenWidth())); painter->setPen(pagePen); painter->drawRect(rect); QRect point(0, 0, size, size); painter->setPen(Qt::NoPen); painter->setBrush(Qt::lightGray); const double fillWidth = rect.x() + rect.width() - shiftX; const double fillHeight = rect.y() + rect.height() - shiftY; for (double y = rect.y() + shiftY; y < fillHeight; y += step) { for (double x = rect.x() + shiftX; x < fillWidth; x += step) { point.moveTo(x, y); painter->drawEllipse(point); } } }
TEST(AgradFwdFmod,FvarFvarVar_FvarFvarVar_2ndDeriv_x) { using stan::agrad::fvar; using stan::agrad::var; using std::fmod; fvar<fvar<var> > x; x.val_.val_ = 3.0; x.val_.d_ = 1.0; fvar<fvar<var> > y; y.val_.val_ = 6.0; y.d_.val_ = 1.0; fvar<fvar<var> > a = fmod(x,y); EXPECT_FLOAT_EQ(fmod(3.0,6.0), a.val_.val_.val()); EXPECT_FLOAT_EQ(1, a.val_.d_.val()); EXPECT_FLOAT_EQ(0, a.d_.val_.val()); EXPECT_FLOAT_EQ(0, a.d_.d_.val()); AVEC q = createAVEC(x.val_.val_,y.val_.val_); VEC r; a.val_.d_.grad(q,r); EXPECT_FLOAT_EQ(0, r[0]); EXPECT_FLOAT_EQ(0, r[1]); }
// an alternate version of transit to deal with longitudes in the direct // problem. static inline int transitdirect(real lon1, real lon2) { using std::fmod; // We want to compute exactly // int(floor(lon2 / 360)) - int(floor(lon1 / 360)) // Since we only need the parity of the result we can use std::remquo but // this is buggy with g++ 4.8.3 and requires C++11. So instead we do lon1 = fmod(lon1, real(720)); lon2 = fmod(lon2, real(720)); return ( ((lon2 >= 0 && lon2 < 360) || lon2 < -360 ? 0 : 1) - ((lon1 >= 0 && lon1 < 360) || lon1 < -360 ? 0 : 1) ); }
inline fvar<T> fmod(const fvar<T>& x1, double x2) { using std::fmod; if (unlikely(is_nan(value_of(x1.val_)) || is_nan(x2))) return fvar<T>(fmod(x1.val_, x2), NOT_A_NUMBER); else return fvar<T>(fmod(x1.val_, x2), x1.d_ / x2); }
inline fvar<T> fmod(const fvar<T>& x1, const double x2) { using std::fmod; using stan::math::value_of; if (unlikely(boost::math::isnan(value_of(x1.val_)) || boost::math::isnan(x2))) return fvar<T>(fmod(x1.val_,x2),stan::math::NOT_A_NUMBER); else return fvar<T>(fmod(x1.val_, x2), x1.d_ / x2); }
void Rotation<T>::normalize() { using std::fmod; if (radians_ > pi) { radians_ = fmod(radians_ + pi, double_pi) - pi; } else if (radians_ < -pi) { radians_ = fmod(radians_ - pi, double_pi) + pi; } }
inline fvar<T> fmod(const double x1, const fvar<T>& x2) { using std::fmod; using std::floor; return fvar<T>(fmod(x1, x2.val_), -x2.d_ * floor(x1 / x2.val_)); }
inline fvar<typename stan::return_type<T1,T2>::type> fmod(const fvar<T1>& x1, const T2& x2) { using std::fmod; return fvar<typename stan::return_type<T1,T2>::type>( fmod(x1.val_, x2), x1.d_ / x2); }
T repeat(T val, T min, T max) { using std::fmod; T temp = fmod(val - min, max - min); if (temp < T{0}) temp += max - min; return temp + min; }
inline fvar<T> fmod(const fvar<T>& x1, const fvar<T>& x2) { using std::fmod; using std::floor; return fvar<T>(fmod(x1.val_, x2.val_), x1.d_ - x2.d_ * floor(x1.val_ / x2.val_)); }
string td3Math::mod(vector<vector<string> > operands) { bool op1 = td3Utility::isFloat(operands.at(0).at(0)); bool op2 = td3Utility::isFloat(operands.at(1).at(0)); return td3Utility::toString( fmod( td3Utility::stof(operands.at(0).at(0)), td3Utility::stof(operands.at(1).at(0))), op1 || op2); }
TEST(AgradFwdFmod,Double_FvarVar_1stDeriv) { using stan::agrad::fvar; using stan::agrad::var; using std::fmod; double x(3.0); fvar<var> z(6.0,1.0); fvar<var> a = fmod(x,z); EXPECT_FLOAT_EQ(fmod(3.0,6.0), a.val_.val()); EXPECT_FLOAT_EQ(0, a.d_.val()); AVEC y = createAVEC(z.val_); VEC g; a.val_.grad(y,g); std::isnan(g[0]); }
inline fvar<typename stan::return_type<T1,T2>::type> fmod(const T1& x1, const fvar<T2>& x2) { using std::fmod; using std::floor; return fvar<typename stan::return_type<T1,T2>::type>( fmod(x1, x2.val_), -x2.d_ * floor(x1 / x2.val_)); }
TEST(AgradFwdFmod,FvarVar_Double_2ndDeriv) { using stan::agrad::fvar; using stan::agrad::var; using std::fmod; fvar<var> x(3.0,1.3); double z(6.0); fvar<var> a = fmod(x,z); EXPECT_FLOAT_EQ(fmod(3.0,6.0), a.val_.val()); EXPECT_FLOAT_EQ(13.0 / 60.0, a.d_.val()); AVEC y = createAVEC(x.val_); VEC g; a.d_.grad(y,g); EXPECT_FLOAT_EQ(0,g[0]); }
TEST(AgradFwdFmod,FvarVar_FvarVar_2ndDeriv) { using stan::agrad::fvar; using stan::agrad::var; using std::fmod; fvar<var> x(3.0,1.3); fvar<var> z(6.0,1.0); fvar<var> a = fmod(x,z); EXPECT_FLOAT_EQ(fmod(3.0,6.0), a.val_.val()); EXPECT_FLOAT_EQ(1.3, a.d_.val()); AVEC y = createAVEC(x.val_,z.val_); VEC g; a.d_.grad(y,g); EXPECT_FLOAT_EQ(0,g[0]); std::isnan(g[1]); }
// an alternate version of transit to deal with longitudes in the direct // problem. static inline int transitdirect(real lon1, real lon2) { // We want to compute exactly // int(floor(lon2 / 360)) - int(floor(lon1 / 360)) // Since we only need the parity of the result we can use std::remquo; // but this is buggy with g++ 4.8.3 (glibc version < 2.22), see // https://sourceware.org/bugzilla/show_bug.cgi?id=17569 // and requires C++11. So instead we do #if GEOGRAPHICLIB_CXX11_MATH && GEOGRAPHICLIB_PRECISION != 4 using std::remainder; lon1 = remainder(lon1, real(720)); lon2 = remainder(lon2, real(720)); return ( (lon2 >= 0 && lon2 < 360 ? 0 : 1) - (lon1 >= 0 && lon1 < 360 ? 0 : 1) ); #else using std::fmod; lon1 = fmod(lon1, real(720)); lon2 = fmod(lon2, real(720)); return ( ((lon2 >= 0 && lon2 < 360) || lon2 < -360 ? 0 : 1) - ((lon1 >= 0 && lon1 < 360) || lon1 < -360 ? 0 : 1) ); #endif }
TEST(AgradFwdFmod,FvarFvarDouble) { using stan::agrad::fvar; using std::fmod; fvar<fvar<double> > x; x.val_.val_ = 3.0; x.val_.d_ = 1.0; fvar<fvar<double> > y; y.val_.val_ = 6.0; y.d_.val_ = 1.0; fvar<fvar<double> > a = fmod(x,y); EXPECT_FLOAT_EQ(fmod(3.0,6.0), a.val_.val_); EXPECT_FLOAT_EQ(1, a.val_.d_); EXPECT_FLOAT_EQ(0, a.d_.val_); EXPECT_FLOAT_EQ(0, a.d_.d_); }
inline quantity<Unit, Y> fmod(const quantity<Unit,Y>& q1, const quantity<Unit,Y>& q2) { using std::fmod; typedef quantity<Unit,Y> quantity_type; return quantity_type::from_value(fmod(q1.value(), q2.value())); }
TEST(AgradFvar, fmod) { using stan::agrad::fvar; using std::fmod; using std::floor; fvar<double> x(2.0); fvar<double> y(3.0); x.d_ = 1.0; y.d_ = 2.0; fvar<double> a = fmod(x, y); EXPECT_FLOAT_EQ(fmod(2.0, 3.0), a.val_); EXPECT_FLOAT_EQ(1.0 * 1.0 + 2.0 * -floor(2.0 / 3.0), a.d_); double z = 4.0; double w = 3.0; fvar<double> e = fmod(x, z); EXPECT_FLOAT_EQ(fmod(2.0, 4.0), e.val_); EXPECT_FLOAT_EQ(1.0 / 4.0, e.d_); fvar<double> f = fmod(w, x); EXPECT_FLOAT_EQ(fmod(3.0, 2.0), f.val_); EXPECT_FLOAT_EQ(1.0 * -floor(3.0 / 2.0), f.d_); }
TEST(AgradFwdFmod,Double_FvarFvarVar_1stDeriv) { using stan::agrad::fvar; using stan::agrad::var; using std::fmod; double x(3.0); fvar<fvar<var> > y; y.val_.val_ = 6.0; y.d_.val_ = 1.0; fvar<fvar<var> > a = fmod(x,y); EXPECT_FLOAT_EQ(fmod(3.0,6.0), a.val_.val_.val()); EXPECT_FLOAT_EQ(0, a.val_.d_.val()); EXPECT_FLOAT_EQ(0, a.d_.val_.val()); EXPECT_FLOAT_EQ(0, a.d_.d_.val()); AVEC q = createAVEC(y.val_.val_); VEC r; a.val_.val_.grad(q,r); EXPECT_FLOAT_EQ(0, r[0]); }
TEST(AgradFwdFmod,FvarFvarVar_Double_1stDeriv) { using stan::agrad::fvar; using stan::agrad::var; using std::fmod; fvar<fvar<var> > x; x.val_.val_ = 3.0; x.val_.d_ = 1.0; double y(6.0); fvar<fvar<var> > a = fmod(x,y); EXPECT_FLOAT_EQ(fmod(3.0,6.0), a.val_.val_.val()); EXPECT_FLOAT_EQ(1.0 / 6.0, a.val_.d_.val()); EXPECT_FLOAT_EQ(0, a.d_.val_.val()); EXPECT_FLOAT_EQ(0, a.d_.d_.val()); AVEC q = createAVEC(x.val_.val_); VEC r; a.val_.val_.grad(q,r); EXPECT_FLOAT_EQ(1, r[0]); }