#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pli = pair<ll, int>;
using pil = pair<int, ll>;
using pdd = pair<double, double>;
using uint = unsigned int;
template <typename T>
using Graph = vector<vector<T>>;
const int MOD = 1e9 + 7;
const ld PI = acosl(-1);

const double EPS = 1e-8;
struct Pt {
    double x, y;
    Pt(double x = 0, double y = 0) : x(x), y(y) {}
};
istream &operator>>(istream &stream, Pt &p) {
    stream >> p.x >> p.y;
    return stream;
}
ostream &operator<<(ostream &stream, Pt p) {
    stream << p.x << " " << p.y;
    return stream;
}
bool operator<(const Pt &p, const Pt &q) {
    if (abs(p.x - q.x) < EPS)
        return p.y < q.y - EPS;
    return p.x < q.x - EPS;
}
inline Pt operator+(const Pt &p, const Pt &q) {
    return Pt(p.x + q.x, p.y + q.y);
}
inline Pt operator-(const Pt &p, const Pt &q) {
    return Pt(p.x - q.x, p.y - q.y);
}
inline Pt operator*(const double &a, const Pt &p) {
    return Pt(p.x * a, p.y * a);
}
inline double dot(const Pt &p, const Pt &q) {
    return p.x * q.x + p.y * q.y;
}
inline double cross(const Pt &p, const Pt &q) {
    return p.x * q.y - p.y * q.x;
}
inline double norm(const Pt &p) {
    return dot(p, p);
}

struct Line {
    Pt s, t;
    Line(Pt s = {0, 0}, Pt t = {0, 0}) : s(s), t(t) {}
};
istream &operator>>(istream &stream, Line &l) {
    stream >> l.s >> l.t;
    return stream;
}
ostream &operator<<(ostream &stream, Line l) {
    stream << l.s << " " << l.t;
    return stream;
}

inline int ccw(const Pt &p1, const Pt &p2, const Pt &q) {
    // qはp1-p2の左側
    if (cross(p2 - p1, q - p1) > EPS)
        return 1;
    // qはp1-p2の右側
    if (cross(p2 - p1, q - p1) < -EPS)
        return -1;
    // q-p1-p2
    if (dot(p2 - p1, q - p1) < -EPS)
        return 2;
    // p1-p2-q
    if (norm(p2 - p1) < norm(q - p1) - EPS)
        return -2;
    // p1-q-p2
    return 0;
}

inline bool intersect(const Line &l, const Line &m) {
    return (ccw(l.s, l.t, m.s) * ccw(l.s, l.t, m.t) <= 0) && (ccw(m.s, m.t, l.s) * ccw(m.s, m.t, l.t) <= 0);
}

inline Line bisec(const Line &l) {
    Pt vvec = {l.t - l.s};
    swap(vvec.x, vvec.y);
    vvec.x = -vvec.x;
    Pt spt = 0.5 * (l.s + l.t);
    return Line(spt, spt + vvec);
}

inline Pt crosspoint(const Line &l, const Line &m) {
    ld k = cross(m.s - l.s, m.s - m.t) / cross(l.t - l.s, m.s - m.t);
    return l.s + k * (l.t - l.s);
}

vector<Pt> convex_hull(vector<Pt> &v) {
    int N = v.size();
    sort(v.begin(), v.end(),
         [](const Pt &p, const Pt &q) {
             if (abs(p.x - q.x) < EPS)
                 return p.y < q.y - EPS;
             return p.x < q.x - EPS;
         });

    vector<Pt> res(N * 2);
    int k = 0;
    for (int i = 0; i < N; ++i) {
        while (k >= 2 && ccw(res[k - 2], res[k - 1], v[i]) < 0)
            k--;
        res[k++] = v[i];
    }
    for (int i = N - 2, t = k; i >= 0; --i) {
        while (k >= t + 1 && ccw(res[k - 2], res[k - 1], v[i]) < 0)
            k--;
        res[k++] = v[i];
    }
    res.resize(k - 1);

    return res;
}

int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);

    int N;
    cin >> N;
    vector<Pt> p(N);
    map<Pt, int> mp;
    for (int i = 0; i < N; ++i) {
        cin >> p[i];
        mp[p[i]] = i;
    }

    vector<double> ans(N);
    auto v = convex_hull(p);
    int vn = v.size();
    if (vn == 2) {
        for (int i = 0; i < vn; ++i)
            ans[mp[v[i]]] = 0.5;
    } else {
        for (int i = 0; i < vn; ++i) {
            int pr = (i - 1 + vn) % vn;
            int nx = (i + 1) % vn;
            Line l1 = bisec(Line(v[i], v[nx]));
            Line l2 = bisec(Line(v[i], v[pr]));
            Pt p1 = l1.s - l1.t;
            Pt p2 = l2.s - l2.t;
            double theta = atan(p1.y / p1.x) - atan(p2.y / p2.x);
            if (theta < 0)
                theta += PI;
            ans[mp[v[i]]] = theta / 2 / PI;
        }
    }

    for (int i = 0; i < N; ++i)
        cout << fixed << setprecision(15) << ans[i] << '\n';

    return 0;
}


Measured memory_bytes: 4172