#include <bits/stdc++.h>

using namespace std;

double eps = 1e-5;

// полный пиздец, больше никогда в жизни не пишу геому
// снизу жизни нет, там только смерть, ужас и страдания
// небольшой стишок
/*
 * Ах, геому я вертел,
 * Кайфануть он захотел...
 * Но задача номер D
 * Отебашила МЕНЯ К ХУЯМ СОБАЧИМ О КАКОЙ ПОЭЗИИ МОЖЕТ ИДТИ РЕЧЬ, КОГДА Я ПИЩУ НА ЯЗЫКЕ КОТОРОМУ ЛЕТ 70
 */
/*
████████████████████████████████████████
████████████▓▒▒▒░░░░░░░░▒▒▒▓████████████
███████░────────────────────────▒███████
████▒──────────────────────────────▒████
███▒─────────────────────────────────███
███──────────────────────────────────▓██
██░───────────────────────────────────██
██───░███████▒────────────▒███████░───██
██──▓█▓░████████░──────░████████░▓█▓──██
█▓─░░─────░▓█████▒────▓█████▓░─────░──▓█
█▒───────────▓██▓─────░▒██▓───────────▓█
█░─────────────██──────██─────────────▒█
█░───▒███████▒──██────░▓──▒███████▒───░█
█░─▒███████████─██──────░███████████▒░░█
█░─████▓▓▓▓▓▓▒░─██░──────▒▒░░░░░▒░░░░─▒█
█░──────────────██░───────────────────░█
██─────────────░██░───────────────────░█
███────────────▓██────────────────────██
██▓█──────────▒███─────░▒───────────░███
██─████▒▒▓▒░░█████─────▒██──▒▓▒░░▒▒█▒███
███─█▓██────▒█▒─██───────▓░─░▒░▒████─███
███▒─█▒██───────█▓─────────────██─█─▒███
████░─█▓███▓░───██▒▒▒▓█░────░███─█▒─████
█████──█▓▒█████████▓███████████░█▓─█████
██████──██──▒█████░──███████▒──█▓─██████
███████──██▓──────░░░░░░──────█▒─███████
████████──██▓░▒▒░░───────────█▒─████████
█████████──█▒──░░▒████▒────░█░─█████████
██████████─░█─────███▒─────▒░─██████████
███████████░─────▒████───────███████████
█████████████────█████─────░████████████
██████████████───▓████────▓█████████████
███████████████───███░──░███████████████
█████████████████▒███▒▒█████████████████
████████████████████████████████████████
████████████████████████████████████████
██████──█──██────██─██─██───██────██████
███████───███─██─██─█─███─████─██─██████
████████─████────██──████───██────██████
███████───███─██─██─█─███─████─█████████
██████──█──██─██─██─██─██───██─█████████
████████████████████████████████████████
*/

struct Point {
    double x, y;

    Point() : x(0), y(0) {}

    Point(double x, double y) : x(x), y(y) {}
};

Point operator+(Point a, Point b) {
    return {a.x + b.x, a.y + b.y};
}

Point operator-(Point a, Point b) {
    return {a.x - b.x, a.y - b.y};
}

Point operator*(double a, Point b) {
    return {a * b.x, a * b.y};
}

double operator*(Point a, Point b) {
    return a.x * b.x + a.y * b.y;
}


double operator^(Point a, Point b) {
    return a.x * b.y - a.y * b.x;
}

istream& operator>>(istream& in, Point& p) {
    in >> p.x >> p.y;
    return in;
}

struct Line {
    double a, b, c;
    Point some;

    Line(Point p1, Point p2) {
        a = p2.y - p1.y;
        b = p1.x - p2.x;
        c = -a * p1.x - b * p1.y;
        some = p1;
    }
};

struct Ray {
    Point p;
    Point dir;
    Line l;

    Ray(Point p1, Point p2) : p(p1), dir(p2 - p1), l(Line(p1, p2)) {}
};

struct Segment {
    Point a, b;
    Line l;

    Segment(Point a, Point b) : a(a), b(b), l(Line(a, b)) {}
};


double dist(Point a, Point b) {
    return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

double dist(Point p, Line l) {
    return abs(l.a * p.x + l.b * p.y + l.c) / sqrt(l.a * l.a + l.b * l.b);
}

double dist(Point p, Ray r) {
    double angle = r.dir * (p - r.p);

    if (angle < 0) {
        return dist(r.p, p);
    }

    return dist(p, r.l);
}

double dist(Point p, Segment s) {
    double angleA = (s.b - s.a) * (p - s.a);

    if (angleA <= 0) {
        return dist(s.a, p);
    }

    double angleB = (s.b - s.a) * (p - s.b);

    if (angleB >= 0) {
        return dist(s.b, p);
    }

    return dist(p, s.l);
}

// point / infinite/no intersections
variant<Point, bool> intersect(Line l1, Line l2) {
    Point A(l1.a, l1.b), B(l2.a, l2.b);

    if (abs(A ^ B) < eps) {
        return abs(l1.some.x * l2.a + l1.some.y * l2.b + l2.c) < eps;
    }


    double y = (l1.a * l2.c - l2.a * l1.c) / (l1.b * l2.a - l1.a * l2.b);
    double x;
    if (abs(l1.a) > eps) {
        x = (-l1.c - l1.b * y) / l1.a;
    } else {
        x = (-l2.c - l2.b * y) / l2.a;
    }
    return Point(x, y);
}

double dist(Segment s1, Segment s2) {
    double pts = min({dist(s1.a, s2),
                      dist(s1.b, s2),
                      dist(s2.a, s1),
                      dist(s2.b, s1)});

    auto i = intersect(s1.l, s2.l);

    if (holds_alternative<Point>(i)) {
        Point p = get<Point>(i);

        if (dist(p, s1) < eps && dist(p, s2) < eps)
            pts = 0;
    }

    return pts;
}


double dist(Ray r, Segment s) {
    double pts = min({dist(r.p, s),
                      dist(s.a, r),
                      dist(s.b, r)});

    auto i = intersect(r.l, s.l);
    if (holds_alternative<Point>(i)) {
        Point p = get<Point>(i);

        if (dist(p, s) < eps && dist(p, r) < eps)
            pts = 0;
    }

    return pts;
}

double dist(Line l, Segment s) {
    double pts = min(dist(s.a, l),
                     dist(s.b, l));

    auto i = intersect(l, s.l);

    if (holds_alternative<Point>(i)) {
        Point p = get<Point>(i);

        if (dist(p, s) < eps && dist(p, l) < eps)
            pts = 0;
    }

    return pts;
}

double dist(Ray r1, Ray r2) {
    double pts = min(dist(r1.p, r2),
                     dist(r2.p, r1));

    auto i = intersect(r1.l, r2.l);

    if (holds_alternative<Point>(i)) {
        Point p = get<Point>(i);

        if (dist(p, r1) < eps && dist(p, r2) < eps)
            pts = 0;
    }

    return pts;
}

double dist(Line l, Ray r) {
    double pts = dist(r.p, l);

    auto i = intersect(l, r.l);

    if (holds_alternative<Point>(i)) {
        Point p = get<Point>(i);

        if (dist(p, l) < eps && dist(p, r) < eps)
            pts = 0;
    }

    return pts;
}

double dist(Line l1, Line l2) {
    auto i = intersect(l1, l2);

    if (holds_alternative<Point>(i)) {
        return 0;
    } else {
        if (get<bool>(i))
            return 0;

        return dist(l1.some, l2);
    }
}

int main() {
    Point a, b, c, d;
    cin >> a >> b >> c >> d;

    cout << fixed << setprecision(10);

    cout << dist(a, c) << '\n';
    cout << dist(a, Segment(c, d)) << '\n';
    cout << dist(a, Ray(c, d)) << '\n';
    cout << dist(a, Line(c, d)) << '\n';

    cout << dist(c, Segment(a, b)) << '\n';
    cout << dist(Segment(a, b), Segment(c, d)) << '\n';
    cout << dist(Ray(c, d), Segment(a, b)) << '\n';
    cout << dist(Line(c, d), Segment(a, b)) << '\n';

    cout << dist(c, Ray(a, b)) << '\n';
    cout << dist(Ray(a, b), Segment(c, d)) << '\n';
    cout << dist(Ray(a, b), Ray(c, d)) << '\n';
    cout << dist(Line(c, d), Ray(a, b)) << '\n';

    cout << dist(c, Line(a, b)) << '\n';
    cout << dist(Line(a, b), Segment(c, d)) << '\n';
    cout << dist(Line(a, b), Ray(c, d)) << '\n';
    cout << dist(Line(a, b), Line(c, d)) << '\n';
}