#include <iostream>
#include <tuple>
#include <sstream>
#include <vector>
#include <cmath>
#include <ctime>
#include <bitset>
#include <cassert>
#include <cstdio>
#include <queue>
#include <set>
#include <map>
#include <fstream>
#include <cstdlib>
#include <string>
#include <cstring>
#include <algorithm>
#include <numeric>
#include <iomanip>

using namespace std;

typedef long long ll;
typedef long double ld; // or double

const ld pi = acos(-1);
const ld eps = ld(1e-9);

bool eq(ld a, ld b) {
    return fabs(a - b) < eps;
}

bool ls(ld a, ld b) {
    return !eq(a, b) && a < b;
}

bool lsoreq(ld a, ld b) {
    return eq(a, b) || ls(a, b);
}

ld sqr(ld x) {
    return x * x;
}

ld mysqrt(ld x) {
    if (x < 0 && !eq(x, 0)) {
        throw "sqrt(-1)";
    }
    if (x < 0) {
        return 0;
    }
    return sqrt(x);
}

ld myasin(ld x) {
	if (eq(x, 1)) {
		return asin(1);
	} else if (eq(x, -1)) {
		return asin(-1);
	} else if (ls(x, -1) || ls(1, x)) {
		throw "asin";
	} else {
		return asin(x);
	}
}

ld myacos(ld x) {
	if (eq(x, 1)) {
		return acos(1);
	} else if (eq(x, -1)) {
		return acos(-1);
	} else if (ls(x, -1) || ls(1, x)) {
		throw "acos";
	} else {
		return acos(x);
	}
}

struct Vector {
    ld x, y;
    Vector() : x(0), y(0) {}
    Vector(ld a, ld b) : x(a), y(b) {}
    void scan() { cin >> x >> y; }
    void print() { cout << x << " " << y; }
    ld operator*(const Vector &v) const {
        return x * v.x + y * v.y;
    }
    ld operator%(const Vector &v) const {
        return x * v.y - y * v.x;
    }
    Vector operator-(const Vector &v) const {
        return Vector(x - v.x, y - v.y);
    }
    Vector operator+(const Vector &v) const {
        return Vector(x + v.x, y + v.y);
    }
    Vector operator*(const ld &k) const {
        return Vector(x * k, y * k);
    }
    Vector operator/(const ld &k) const {
        return Vector(x / k, y / k);
    }
    bool operator==(const Vector &v) const {
        return eq(x, v.x) && eq(y, v.y);
    }
    ld len() {
        return mysqrt((*this) * (*this));
    }
	ld getAngle(Vector &p) const {
        Vector v = *this;
        return atan2(v % p, v * p);
    }
};

pair <Vector, Vector> getLine3(ld a, ld b, ld c) {
    if (a == 0) {
        return {Vector(0, -c / b), Vector(1, -c / b)};
    } else if (b == 0) {
        return {Vector(-c / a, 0), Vector(-c / a, 1)};
    } else {
        return {Vector(0, -c / b), Vector(1, -(a + c) / b)};
    }
}

struct Line {
    Vector A, B;
    Line() : A(), B() {}
    Line(Vector A1, Vector B1) : A(A1), B(B1) {}
    Line(ld a, ld b, ld c) : A(getLine3(a, b, c).first), B(getLine3(a, b, c).second) {}
    void scan() { A.scan(); B.scan(); }
    void scan3() { ld a, b, c; cin >> a >> b >> c; A = getLine3(a, b, c).first; B = getLine3(a, b, c).second; };
};

struct Circle {
    Vector O;
    ld r;
    Circle() : O(), r(0) {}
    Circle(Vector v, ld a) : O(v), r(a) {}
    void scan() { O.scan(); cin >> r; }
    bool operator==(const Circle &w) const {
        return eq(r, w.r) && O == w.O;
    }
};

struct Segment {
    Vector A, B;
    Segment() : A(), B() {}
    Segment(Vector A1, Vector B1) : A(A1), B(B1) {}
    void scan() { A.scan(); B.scan(); }
    bool operator==(const Segment &v) {
        return (A == v.A && B == v.B) || (A == v.B && B == v.A);
    }
};

bool isz(const Vector &v) {
    return eq(v.x, 0) && eq(v.y, 0);
}

Vector norm(Vector v, ld k = 1) {
    if (eq(v.len(), 0)) {
        if (eq(k, 0)) {
            return Vector();
        } else {
            throw "zero-size Vector /*from norm*/";
        }
    }
    return v * (k / v.len());
}

bool isOnLine(const Vector &v, const Line &a) {
    return eq((a.A - v) % (a.B - v), 0);
}

bool isOnSegment(const Vector &C, const Segment &a) {
    Line b(a.A, a.B);
    return isOnLine(C, b) && lsoreq((a.A - C) * (a.B - C), 0);
}

ld dtp(const Vector &v, const Vector &u) {
    ld a = v.x - u.x;
    ld b = v.y - u.y;
    return mysqrt(sqr(a) + sqr(b));
}

ld dtl(const Vector &v, const Line &a) {
    ld d = dtp(a.A, a.B);
    if (eq(d, 0)) {
        throw "A == B";
    }
    ld s = (v - a.A) % (v - a.B);
    return fabs(s) / d;
}

Vector getH(const Vector &C, const Line &a) {
    Vector v = a.B - a.A;
    Vector u = C - a.A;
    ld k = (v * u) / v.len();
    v = norm(v, k);
    return a.A + v;
}

ld dts(const Vector &C, const Segment &a) {
	if (isOnSegment(C, a)) {
		return 0;
	} 
	Line b(a.A, a.B); 
	Vector H = getH(C, b);
	if (isOnSegment(H, a)) {
		return dtp(C, H);
	} else {
		return min(dtp(C, a.A), dtp(C, a.B));
	} 
}

pair <int, Vector> intersection(const Line &a, const Line &b) {
    Vector v = a.B - a.A;
    ld s1 = (b.A - a.A) % (b.B - a.A);
    ld s2 = (b.B - a.B) % (b.A - a.B);
    ld s = s1 + s2;
    if (eq(s, 0)) {
        if (!isOnLine(a.A, b)) {
            return {0, Vector()};
        } else {
            return {2, Vector()};
        }
    }
    v = v / s;
    v = v * s1;
    return {1, a.A + v};
}

pair <int, Vector> intersection(const Line &a, const Segment &b) {
    Line c(b.A, b.B);
    pair <int, Vector> res = intersection(a, c);
    if (res.first == 0) {
        return {0, Vector()};
    } else if (res.first == 2) {
        return {2, Vector()};
    }
    if (isOnSegment(res.second, b)) {
        return {1, res.second};
    } else {
        return {0, Vector()};
    }
}

/*
bool operator<(const Vector &a, const Vector &b) {
    return ls(a.x, b.x) || (eq(a.x, b.x) && ls(a.y, b.y));
}
You can use it for segment+intersection for num2, res = {a.A, a.B, b.A, b.B}; sort and take minimum
*/

pair <int, Vector> intersection(Segment &a, Segment &b) {
    Line ca(a.A, a.B), cb(b.A, b.B);
    pair <int, Vector> res = intersection(ca, b);
    if (res.first == 0) {
        return {0, Vector()};
    } else if (res.first == 2) {
        if (a == b) {
            return {2, Vector()};
        }
        if (a.A == b.B) {
            if (!isOnSegment(a.B, b) && !isOnSegment(b.A, a)) {
                return {1, a.A};
            }
        }
        if (a.A == b.A) {
            if (!isOnSegment(a.B, b) && !isOnSegment(b.B, a)) {
                return {1, a.A};
            }
        }
        if (a.B == b.A) {
            if (!isOnSegment(a.A, b) && !isOnSegment(b.B, a)) {
                return {1, a.B};
            }
        }
        if (a.B == b.B) {
            if (!isOnSegment(a.A, b) && !isOnSegment(b.A, a)) {
                return {1, a.B};
            }
        }
        if (isOnSegment(a.A, b) || isOnSegment(a.B, b) || isOnSegment(b.A, a) || isOnSegment(b.B, a)) {
            return {2, Vector()};
        } else {
            return {0, Vector()};
        }
    }
    if (isOnSegment(res.second, a) && isOnSegment(res.second, b)) {
        return {1, res.second};
    } else {
        return {0, Vector()};
    }
}

pair <int, vector <Vector> > intersection(const Circle &w, const Line &a) {
    ld h = dtl(w.O, a);
    if (w.r < h) {
        return {0, {}};
    }
    Vector H = getH(w.O, a);
    Vector v = a.B - a.A;
    ld k = mysqrt(sqr(w.r) - sqr(h));
    v = norm(v, k);
    if (isz(v)) {
        return {1, {H + v}};
    } else {
        return {2, {H + v, H - v}};
    }
}

Vector rot90p(const Vector &v) {
    return Vector(-v.y, v.x);
}

Vector rots(const Vector &v, ld sina, ld cosa) {
    Vector u = rot90p(v);
    Vector w = v * cosa + u * sina;
    return w;
}

Vector rotp(const Vector &v, ld al) {
    return rots(v, sin(al), cos(al));
}

pair <int, vector <Vector> > intersection(const Circle &w1, const Circle &w2) {
    ld d = dtp(w1.O, w2.O);
    if (w1.r + w2.r < d || d < fabs(w1.r - w2.r)) {
        return {0, {}};
    }
    if (w1 == w2) {
        return {3, {}};
    }
    ld a = (sqr(w1.r) - sqr(w2.r) + sqr(d)) / ld(2) / d;
    ld h = mysqrt(sqr(w1.r) - sqr(a));
    Vector v = w2.O - w1.O;
    Vector u = rot90p(v);
    v = norm(v, a);
    u = norm(u, h);
    Vector H = w1.O + v;
    if (isz(u)) {
        return {1, {H + u}};
    } else {
        return {2, {H + u, H - u}};
    }
}

pair <int, vector <Vector> > tangent(const Vector &A, const Circle &w)  {
    Vector v = w.O - A;
    ld d = v.len();
    if (d < w.r) {
        return {0, {}};
    }
    ld al = myasin(w.r / d);
    ld L = mysqrt(sqr(d) - sqr(w.r));
    v = norm(v, L);
    Vector N = A + rotp(v, al);
    Vector M = A + rotp(v, -al);
    if (eq(w.r, d)) {
        return {1, {N}};
    } else {
        return {2, {N, M}};
    }
}

/*IF YOU UPOROLSA*/typedef Vector Point;

bool cw(const Point &o, const Point &a, const Point &b) {
    return (a - o) % (b - o) <= 0;
}

void convexHull(vector<Point> &a) {
    sort(a.begin(), a.end(), [&](const Point &p, const Point &q) {
        return p.x < q.x || (p.x == q.x && p.y < q.y);
    });
    vector<Point> res;
    vector<Point> c;
    for (int j = 0; j < 2; ++j) {
        c.clear();
        c.push_back(a[0]);
        for (int i = 1; i < a.size(); ++i) {
            if (i == a.size() - 1 || cw(a[0], a[i], a.back())) {
                while (c.size() > 1 && cw(c[c.size() - 2], a[i], c[c.size() - 1])) {
                    c.pop_back();
                }
                c.push_back(a[i]);
            }
            a[i].y = -a[i].y;
        }
        a[0].y = -a[0].y;
        if (!j) {
            for (auto cc : c) {
                res.push_back(cc);
            }
        }
    }
    for (int i = c.size() - 2; i > 0; --i) {
        c[i].y = -c[i].y;
        res.push_back(c[i]);
    }
    a = res;
}

ld ga(Vector a, Vector b) {
	return max(a.getAngle(b), b.getAngle(a));
}

int main() {
    cout << fixed << setprecision(10);
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
	int n;
	cin >> n;
	vector <Point> a(n), b(n);
	for (int i = 0; i < n; ++i) {
		a[i].scan();
		b[i] = a[i];
	}
	if (n == 2) {
		cout << "0.5\n0.5";
		return 0;
	}
	convexHull(a);
	int m = int(a.size());
	vector <ld> ans(m, -1);
	for (int i = 0; i < m; ++i) {
		Point A = a[(i == 0 ? m - 1 : i - 1)];
		Point B = a[(i == m - 1 ? 0 : i + 1)];
		Vector v = a[i] - B;
		Vector u = A - a[i];
		v = rot90p(v);
		u = rot90p(u);
		ans[i] = ga(v, u);
	}
	for (int i = 0; i < n; ++i) {
		ld vl = 0;
		for (int j = 0; j < m; ++j) {
			if (b[i] == a[j]) {
				vl = ans[j];
				break;
			}
		}
		cout << vl / 2 / pi << "\n";
	}
    return 0;
}


Measured memory_bytes: 256