//#pragma GCC optimize("O3")
////(UNCOMMENT WHEN HAVING LOTS OF RECURSIONS)\
//#pragma comment(linker, "/stack:200000000")
////(UNCOMMENT WHEN NEEDED)
//#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector,fast-math")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include <bits/stdc++.h>

#define fi first
#define se second
#define forn(i,n) for(int i=0; i< (int)n; ++i)
#define for1(i,n) for(int i=1; i<= (int)n; ++i)
#define fore(i,l,r) for(int i=(int)l; i<= (int)r; ++i)
#define fored(i,l,r) for(int i=(int)r; i>= (int)l; --i)
#define pb push_back
#define el '\n'
#define d(x) cout<< #x<< " " << x<<el
#define sz(v) ((int)v.size())
#define all(v) v.begin(),v.end()

using namespace std;

typedef long long ll;
typedef pair<int,int> ii;
typedef tuple<int,int,int> iii;
typedef vector<int> vi;
typedef vector<ll> vll;

const double pi = acos(-1), eps = 1e-9;
const int inf = 1e9, mod = 1e9+7, N = 1e5 + 10;
int x, y; 
double v, w, R, a, nor; 

struct pt {  // for 3D add z coordinate
	double x,y;
	pt(double x, double y):x(x),y(y){}
	pt(){}
	double norm2(){return abs((*this)*(*this));}
	double norm(){return sqrt(norm2());}
	bool operator==(pt p){return abs(x-p.x)<=eps&&abs(y-p.y)<=eps;}
	bool operator!=(pt p){ return !operator==(p);}
	bool operator<(pt p)const{ // for convex hull/set/map
		return x<p.x-eps||(abs(x-p.x)<=eps&&y<p.y-eps);}
	pt operator+(pt p){return pt(x+p.x,y+p.y);}
	pt operator-(pt p){return pt(x-p.x,y-p.y);}
	pt operator*(double t){return pt(x*t,y*t);}
	pt operator/(double t){return pt(x/t,y/t);}
	///DOT
	double operator*(pt p){return x*p.x+y*p.y;}
//	pt operator%(pt p){ // 3D
//		return pt(y*p.z-z*p.y,z*p.x-x*p.z,x*p.y-y*p.x);}
	double angle(pt p){ ///[0, pi]
		double co = *this*p/(norm()*p.norm());
		return acos(max(-1.0, min(1.0, co)));
  }
	pt unit(){return *this/norm();}
	double operator%(pt p){return x*p.y-y*p.x;}
	/// 2D from now on
	bool left(pt p, pt q){ // is it to the left of directed line pq?
		return (q-p)%(*this-p)>eps;
  }
	int left_int(pt p, pt q){ // is it to the left of directed line pq?
		double cro = (q-p)%(*this-p);
		if(cro < eps)
      return -1;
		else
      return (abs(cro) <= eps ? 0 : 1);
  }
	pt rot(pt r){return pt(*this%r,*this*r);}
	pt rot(double a){return rot(pt(sin(a),cos(a)));}
	pt rotp(double a, pt p){
    pt aux = (*this - p).rot(a);
    return aux + p;
  }
};

pt ccw90(1,0), cw90(-1,0);

int sgn(double x){
  if(x<0)
    return -1;
  else if(abs(x) <= eps)
    return 0;
  else
    return 1;
}

int sgn2(double x){return x<0?-1:1;}
struct ln {
	pt p, pq; //POINT + DIRECTION
	ln(pt p, pt q) : p(p), pq(q-p){}
	ln(double a, double b, double c) : p(b == 0 ? pt(-c/a, 0) : pt(0, -c/b)), pq(pt(b, -a)){} ///ax + by + c = 0
	ln(){}
	bool has(pt r){return dist(r)<=eps;} ///check if point belongs
	bool seghas(pt r){return has(r)&&(r-p)*(r-(p+pq))<=eps;} ///check if point belongs to segment PQ
//	bool operator /(ln l){return (pq.unit()^l.pq.unit()).norm()<=eps;} // 3D
	bool operator/(ln l){return abs(pq.unit()%l.pq.unit())<=eps;} /// PARALLEL CHECK
	bool operator==(ln l){return *this/l&&has(l.p);}
	pt operator^(ln l){ /// intersection ln-ln
		if(*this/l) return pt(inf,inf);
		pt r=l.p+l.pq*((p-l.p)%pq/(l.pq%pq));
//		if(!has(r)){return pt(NAN,NAN,NAN);} // check only for 3D
		return r;
	}
	double angle(ln l){return pq.angle(l.pq);}   ///angle bet. 2 lines
	int side(pt r){return has(r)?0:sgn2(pq%(r-p));} /// 1=L, 0= on, -1=R
	pt proj(pt r){return p+pq*((r-p)*pq/pq.norm2());}
	pt refl(pt r){return proj(r)*2-r;}
	double dist(pt r){return (r-proj(r)).norm();}
	double dist2(pt r){return (r - proj(r)).norm2();}
//	ls dist(ln l){ // only 3D
//		if(*this/l)return dist(l.p);
//		return abs((l.p-p)*(pq^l.pq))/(pq^l.pq).norm();
//	}
	ln rot(pt a){return ln(p,p+pq.rot(a));} /// 2D respecto a P
  ln rot(double a){return ln(p,p+pq.rot(a));} /// 2D respecto a P
  ln perp_at(pt r){return ln(r, r+pq.rot(ccw90));}
  bool cmp_proj(pt r, pt s){return pq*r<pq*s;}
  int cmp_int(pt r, pt s){
    if(pq*r < pq*s)
      return -1;
    else
      return (pq*r == pq*s ? 0 : 1);
  }
  ln trans(pt d){ return ln(p + d, pq);}    ///d = dir. vec
};

ln bisec(ln l, ln m){ /// angle bisector
	pt p=l^m;
	return ln(p, p+l.pq.unit()+m.pq.unit());
}
ln bisec(pt p, pt q){ /// segment bisector (2D) (mediatriz)
	return ln((p+q)*.5,p).rot(ccw90);
}
pt perp(pt p) {return {-p.y, p.x};}

struct circle {
	pt o; double r;
	circle(pt o, double r):o(o),r(r){}
	circle(pt x, pt y, pt z){o=bisec(x,y)^bisec(x,z);r=(o-x).norm();}///circumcircle
	bool has(pt p){return (o-p).norm()<r-eps;}
	vector<pt> operator^(circle c){ // ccw
		vector<pt> s;
		double d = (o - c.o).norm();
		if(d > r+c.r+eps || d+min(r,c.r)+eps < max(r,c.r)) return s;
		double x = (d*d - c.r*c.r + r*r)/(2*d);
		double y = sqrt(r*r - x*x);
		pt v = (c.o - o)/d;
		s.pb(o + v*x - v.rot(ccw90)*y);
		if(y>eps) s.pb(o + v*x + v.rot(ccw90)*y);
		return s;
	}
	vector<pt> operator^(ln l){
		vector<pt> s;
		pt p=l.proj(o);
		double d=(p-o).norm();
		if(d-eps>r)return s;
		if(abs(d-r)<=eps){s.pb(p);return s;}
		d=sqrt(r*r-d*d);
		s.pb(p+l.pq.unit()*d);
		s.pb(p-l.pq.unit()*d);
		return s;
	}

  vector<pt> Tang(pt p){
    pt o1 = o, o2 = p;
    double r1 = r, r2 = 0;
    pt d = o2-o1;
    double dr = r1-r2, d2 = d.norm2(), h2 = d2-dr*dr;
    vector<pt> out;
    for (double sign : {-1,1}) {
      pt v = (d*dr + perp(d)*sqrt(h2)*sign)/d2;
      out.pb(o1 + (v*r1));
    }
    return out;
  }
	bool in(circle c){ // non strict
		double d = (o-c.o).norm();
		return d+r <= c.r+eps;
	}
};

double orient(pt a, pt b, pt c){  ///C: >0 left, ==0 on AB, <0 right
  return (b-a)%(c-a);
}

double small_angle(pt p, pt q){   ///[0, pi] ([0, 180])
  return acos(max(-1.0, min((p*q)/(p.norm()*q.norm()), 1.0)));
}

double dir_ang_CCW(pt a, pt b, pt c){ ///Vertex = B,  from BA -> BC (CCW)
  if(orient(a,b,c) <= 0){
    return small_angle(a-b, c-b);
  } else{
    return 2*pi - small_angle(a-b, c-b);
  }
}

double calc(double m){
  double xx = nor*cos(a-m), yy = nor*sin(a-m);
  assert(yy >= 0);

  pt p(xx, yy), cen(0, R);
  circle c(cen, R);

  if(c.has(p)) return 1e9;
  
  auto pts = c.Tang(p);
  pt best, o(0,0);
  if(sz(pts) > 1){
    if(dir_ang_CCW(o, cen, pts[0]) > dir_ang_CCW(o, cen, pts[1])) 
      best = pts[1];
    else 
      best = pts[0];
  } else if(isnan(pts[0].x) || isnan(pts[0].y))
    best = p;
  else 
    best = pts[0];

  double ans = m/w + (dir_ang_CCW(o, cen, best)*R + (p - best).norm())/v;
  //d(m/w);d(ans);d(dir_ang_CCW(o, cen, best)*r);d((p - best).norm());
  pt b = p - best;
  //d(pts[0].x); d(best.y);d(sz(pts));
  return ans;
}

double solve1(){
  cin >> x >> y;
  y = abs(y);
  cin >> v >> w;
  R = v/w;
  a = atan2(y, x);
  nor = sqrt(x*x+y*y);

  double l= 0, r=a, ans = min(calc(l), calc(r)), inf = 1e9;
  ans = min({ans,calc(l), calc(r)});
  while(r-l > eps){
    double m1 = (2l + r)/3, m2= (l + 2*r)/3.0;
    double v1 = calc(m1), v2 = calc(m2);
    if(v1 == inf && v2 == inf){
      double vl = calc(l), vr = calc(r);
      assert(vl < inf || vr < inf);
      if(calc(r) < inf){
        l = m2;
      } else{
        r = m1;
      }
    } else if(v2 < v1){
      l = m1;
    } else{
      r = m2;
    }
  }
  ans = min({ans,calc(l), calc(r)});
  return ans;
}

int main(){
  //ios_base::sync_with_stdio(false);
  //cin.tie(NULL); cout.tie(NULL);
  cout << setprecision(10) << fixed;  
  double a1 = solve1();
  cout << a1 << el;
}