import java.io.*;
import java.util.*;
import java.math.*;

public class move_ab implements Runnable {
    public static void main(String[] args) {
	new Thread(new move_ab()).start();
    }

    @Override
    public void run() {
	try {
	    br = new BufferedReader(new FileReader("move.in"));
	    out = new PrintWriter("move.out");
	    solve();
	    out.close();
	} catch (Throwable e) {
	    e.printStackTrace();
	    System.exit(-1);
	}
    }

    BufferedReader br;
    StringTokenizer st;
    PrintWriter out;
    boolean eof = true;

    String cnv(String a) {
	return a.equals("") ? "0" : a;
    }

    String nextToken() {
	while (st == null || !st.hasMoreElements()) {
	    try {
		st = new StringTokenizer(br.readLine());
	    } catch (Exception e) {
		eof = true;
		return "";
	    }
	}
	return st.nextToken();
    }

    int nextInt() {
	return Integer.parseInt(cnv(nextToken()));
    }

    double nextDouble() {
	return Double.parseDouble(cnv(nextToken()));
    }

    final int MAX_C = 1000;
    final int MAX_V = 1000;

    double x1, y1, x2, y2, x3, y3, xd, yd, v1, v2;

    private void solve() throws IOException {
	x1 = nextInt();
	y1 = nextInt();
	x2 = nextInt();
	y2 = nextInt();
	x3 = nextInt();
	y3 = nextInt();
	xd = nextInt();
	yd = nextInt();
	v1 = nextInt();
	v2 = nextInt();

	myAssert(Math.abs(x1) <= MAX_C);
	myAssert(Math.abs(y1) <= MAX_C);
	myAssert(Math.abs(x2) <= MAX_C);
	myAssert(Math.abs(y2) <= MAX_C);
	myAssert(Math.abs(x3) <= MAX_C);
	myAssert(Math.abs(y3) <= MAX_C);
	myAssert(Math.abs(xd) <= MAX_C);
	myAssert(Math.abs(yd) <= MAX_C);
	myAssert(1 <= v2 && v2 <= MAX_V);
	myAssert(v2 < v1 && v1 <= MAX_V);

	double a = y1 - yd;
	double b = xd - x1;
	double d = Math.sqrt(a * a + b * b);
	a /= d;
	b /= d;
	double c = -x1 * a - y1 * b;

	if (sign(a * x2 + b * y2 + c) * sign(a * x3 + b * y3 + c) >= 0) {
	    out.println(Math.hypot(xd - x1, yd - y1) / v1);
	} else {
	    a = y2 - y3;
	    b = x3 - x2;
	    d = Math.sqrt(a * a + b * b);
	    a /= d;
	    b /= d;
	    c = -x2 * a - y2 * b;

	    if (sign(a * x1 + b * y1 + c) * sign(a * xd + b * yd + c) < 0) {
		double ans = TernarSearch(new Path1_23_d());
		ans = Math.min(ans, Math.hypot(x1 - x2, y1 - y2) / v1 + Math.hypot(xd - x2, yd - y2) / v1);
		ans = Math.min(ans, Math.hypot(x1 - x3, y1 - y3) / v1 + Math.hypot(xd - x3, yd - y3) / v1);
		ans = Math.min(ans, TernarSearch(new Path1_12_23_d()));
		ans = Math.min(ans, TernarSearch(new Path1_13_23_d()));
		out.println(ans);
	    } else {
		double ans = Math.hypot(xd - x1, yd - y1) / v2;
		ans = Math.min(ans, TernarSearch(new Path1_12_d()));
		ans = Math.min(ans, TernarSearch(new Path1_13_d()));
		ans = Math.min(ans, TernarSearch(new Path1_2_23_d()));
		ans = Math.min(ans, TernarSearch(new Path1_3_23_d()));
		out.println(ans);
	    }
	}

    }

    double TernarSearch(Functor fun) {
	double ll = 0;
	double rr = 1;
	for (int q = 0; q < 100; ++q) {
	    double lr = (2 * ll + rr) / 3;
	    double rl = (ll + 2 * rr) / 3;
	    double lrv = fun.call(lr);
	    double rlv = fun.call(rl);
	    if (lrv > rlv) {
		ll = lr;
	    } else {
		rr = rl;
	    }
	}
	return fun.call(ll);
    }

    interface Functor {
	public double call(double a);
    }

    class Path1_23_d implements Functor {
	@Override
	public double call(double a) {
	    double x = x2 * a + x3 * (1 - a);
	    double y = y2 * a + y3 * (1 - a);
	    return Math.sqrt((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y)) / v2
		    + Math.sqrt((xd - x) * (xd - x) + (yd - y) * (yd - y)) / v1;
	}
    }

    class Path1_12_d implements Functor {
	@Override
	public double call(double a) {
	    double x = a * x1 + (1 - a) * x2;
	    double y = a * y1 + (1 - a) * y2;
	    return Math.hypot(x1 - x, y1 - y) / v1 + Math.hypot(xd - x, yd - y) / v2;
	}
    }

    class Path1_13_d implements Functor {
	@Override
	public double call(double a) {
	    double x = a * x1 + (1 - a) * x3;
	    double y = a * y1 + (1 - a) * y3;
	    return Math.hypot(x1 - x, y1 - y) / v1 + Math.hypot(xd - x, yd - y) / v2;
	}
    }

    class Path1_2_23_d implements Functor {
	@Override
	public double call(double a) {
	    double x = x2 * a + x3 * (1 - a);
	    double y = y2 * a + y3 * (1 - a);
	    return Math.hypot(x1 - x2, y1 - y2) / v1 + Math.hypot(x - x2, y - y2) / v1 + Math.hypot(xd - x, yd - y)
		    / v2;
	}
    }

    class Path1_3_23_d implements Functor {
	@Override
	public double call(double a) {
	    double x = x2 * a + x3 * (1 - a);
	    double y = y2 * a + y3 * (1 - a);
	    return Math.hypot(x1 - x3, y1 - y3) / v1 + Math.hypot(x - x3, y - y3) / v1 + Math.hypot(xd - x, yd - y)
		    / v2;
	}
    }

    class Patha_23_d implements Functor {
	double ax, ay;

	public Patha_23_d(double ax, double ay) {
	    this.ax = ax;
	    this.ay = ay;
	}

	@Override
	public double call(double a) {
	    double x = x2 * a + x3 * (1 - a);
	    double y = y2 * a + y3 * (1 - a);
	    return Math.hypot(ax - x, ay - y) / v2 + Math.hypot(xd - x, yd - y) / v1;
	}
    }

    class Path1_12_23_d implements Functor {
	@Override
	public double call(double a) {
	    double x = a * x1 + (1 - a) * x2;
	    double y = a * y1 + (1 - a) * y2;
	    return Math.hypot(x1 - x, y1 - y) / v1 + TernarSearch(new Patha_23_d(x, y));
	}
    }

    class Path1_13_23_d implements Functor {
	@Override
	public double call(double a) {
	    double x = a * x1 + (1 - a) * x3;
	    double y = a * y1 + (1 - a) * y3;
	    return Math.hypot(x1 - x, y1 - y) / v1 + TernarSearch(new Patha_23_d(x, y));
	}
    }
    
    final double eps = 1e-9;

    int sign(double v) {
	if (v < -eps)
	    return -1;
	if (v > eps)
	    return 1;
	return 0;
    }

    void myAssert(boolean e) {
	if (!e) {
	    throw new Error("assertion failed");
	}
    }

}
