#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
#define FOR(i,j,k) for(int (i)=(j);(i)<(int)(k);++(i))
#define rep(i,j) FOR(i,0,j)
#define each(x,y) for(auto &(x):(y))
#define mp make_pair
#define MT make_tuple
#define all(x) (x).begin(),(x).end()
#define debug(x) cout<<#x<<": "<<(x)<<endl
#define smax(x,y) (x)=max((x),(y))
#define smin(x,y) (x)=min((x),(y))
#define MEM(x,y) memset((x),(y),sizeof (x))
#define sz(x) (int)(x).size()
#define RT return
#define vv(a,b,c,d) vector<vector<a> >(b,vector<a>(c,d))
#define vvv(a,b,c,d,e) vector<vector<vector<a> > >(b,vv(a,c,d,e))
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vll = vector<ll>;

/*
複素数を使った簡単な幾何
*/
typedef complex<double> P;
double cross(P a, P b) {
    return imag(conj(a)*b);
}
double dot(P a, P b) {
    return real(conj(a)*b);
}
/*
a->b->cと進むときの点の進行方向
+1: 反時計回り
-1: 時計回り
+2: c--a--b
-2: a--b--c
http://www.prefield.com/algorithm/geometry/ccw.html
*/
int ccw(P a, P b, P c) {
    b = b - a; c = c - a;
    if (cross(b, c) > 0) return +1;
    if (cross(b, c) < 0) return -1;
    if (dot(b, c) < 0) return +2;
    if (norm(b) < norm(c)) return -2;
    return 0;
}

/*
凸包を求める
O(nlgn)
Andrew's Monotone Chain
www.prefield.com/algorithm/geometry/convex_hull.html
*/
vector<P> convexHull(vector<P> ps) {
    int n = (int)ps.size();
    sort(begin(ps), end(ps), [&](P a, P b) {
        if (a.real() != b.real())return a.real() < b.real();
        else return a.imag() < b.imag();
    });
    int k = 0;
    vector<P> qs(n * 2);
    for (int i = 0; i<n; ++i) {
        while (k > 1 && ccw(qs[k - 2], qs[k - 1], ps[i]) <= 0) k--;
        qs[k++] = ps[i];
    }
    for (int i = n - 2, t = k; i >= 0; --i) {
        while (k>t && ccw(qs[k - 2], qs[k - 1], ps[i]) <= 0) k--;
        qs[k++] = ps[i];
    }
    qs.resize(k - 1);
    return qs;
}

/*
凸法を重心を中心にして偏角ソートする
(反時計回りにする)
*/
vector<P> sortConvexHull(vector<P> vertices) {
    // 重心
    P center(0, 0);
    for (P vertex : vertices) {
        center += vertex;
    }
    int number = (int)vertices.size();
    center /= number;
    vector<pair<double, int> > ordered(number);
    for (int i = 0; i < number; ++i) {
        P vertex = vertices[i] - center;
        ordered[i] = make_pair(atan2(vertex.imag(), vertex.real()), i);
    }
    sort(ordered.begin(), ordered.end());
    vector<P> res(number);
    for (int i = 0; i < number; ++i) {
        res[i] = vertices[ordered[i].second];
    }
    return res;
}

const int R = (int)2e6;
int N, X[100], Y[100], cnt[100];
map<pii, int> id;
double ans[100];

int f(P p) {
    return id[mp((int)round(p.real()), (int)round(p.imag()))];
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout << fixed << setprecision(20);

    cin >> N;
    vector<P> vertices(N);
    rep(i, N) {
        cin >> X[i] >> Y[i];
        vertices[i] = P(X[i], Y[i]);
        id[mp(X[i], Y[i])] = i;
    }

    auto hull = convexHull(vertices);

    if (sz(hull) == 2) {
        each(p, hull) {
            ans[f(p)] = 0.5;
        }
    } else {
        hull = sortConvexHull(hull);
        int K = sz(hull);
        rep(j, K) {
            int i = (K + j - 1) % K;
            int k = (K + j + 1) % K;
            P a = (hull[j] - hull[i])*P(1, 0);
            P b = (hull[k] - hull[j])*P(1, 0);
            double d = acos(dot(a, b) / (abs(a)*abs(b)));
            ans[f(hull[j])] = d / M_PI * 0.5;
        }
    }

    rep(i, N) {
        cout << ans[i] << endl;
    }
}

Measured memory_bytes: 512