// Why am I so dumb? :c
#include<bits/stdc++.h>

#define pb push_back
#define mp make_pair

#define all(x) (x).begin(), (x).end()

#define fi first
#define se second

using namespace std;

typedef long long ll;

struct pt {
    /// Point structure for Int in C++
    int x, y;

    /// CONSTRUCTORS

    pt() : x(0), y(0) {}
    pt(int x, int y) : x(x), y(y) {}

    /// INPUT/OUTPUT

    void print() {
        printf("(%d, %d)", x, y);
    }

    void println() {
        print();
        printf("\n");
    }

    bool read() {
        return scanf("%d %d", &x, &y) == 2;
    }

    /// OPERATORS

    const pt operator +(pt other) {
        return pt(x + other.x, y + other.y);
    }

    const pt operator +(int c) {
        return pt(x + c, y + c);
    }

    const pt operator -(pt other) {
        return pt(x - other.x, y - other.y);
    }

    const pt operator -(int c) {
        return pt(x - c, y - c);
    }

    pt& operator +=(pt other) {
        x += other.x;
        y += other.y;
        return *this;
    }

    pt& operator +=(int c) {
        x += c; y += c;
        return *this;
    }

    pt& operator -=(pt other) {
        x -= other.x;
        y -= other.y;
        return *this;
    }

    pt& operator -=(int c) {
        x -= c; y -= c;
        return *this;
    }

    const pt operator *(int c) {
        return pt(x * c, y * c);
    }

    pt& operator *=(int c) {
        x *= c; y *= c;
        return *this;
    }

    const pt operator /(int c) {
        return pt(x / c, y / c);
    }

    pt& operator /=(int c) {
        x /= c; y /= c;
        return *this;
    }

    pt& operator =(pt other) {
        x = other.x;
        y = other.y;
        return *this;
    }

    /// FUNCTIONS

    ll distSq(pt p) {
        return (x - p.x) * 1ll * (x - p.x) + (y - p.y) * 1ll * (y - p.y);
    }

    double dist(pt p) {
        return sqrt(distSq(p));
    }

    double magnitude() {
        return dist(pt(0, 0));
    }

    int orient(pt a, pt b) {
        ll val = (a.y - y) * 1ll * (b.x - a.x) - (a.x - x) * 1ll * (b.y - a.y);

        if (val == 0) {
            return 0;
        }

        return (val < 0 ? -1 : 1);
    }
};

const bool operator <(pt a, pt b) {return (a.x == b.x ? a.y < b.y : a.x < b.x);}
const bool operator >(pt a, pt b) {return b < a;}
const bool operator ==(pt a, pt b) {return (a.x == b.x && a.y == b.y);}
const bool operator <=(pt a, pt b) {return !(a > b);}
const bool operator >=(pt a, pt b) {return !(a < b);}
const bool operator !=(pt a, pt b) {return !(a == b);}

pt convexHullP;

bool convexHullCmp(pt a, pt b) {
    int cur = convexHullP.orient(a, b);

    if (cur == 0) {
        return convexHullP.distSq(a) < convexHullP.distSq(b);
    }

    return cur == -1;
}

struct convexHull {
    vector<pt> V;

    convexHull() {
        V.clear();
    }

    convexHull(vector<pt> _V) {
        V = _V;
    }

    void solve() {
        int n = V.size(), k = 0;
        vector<pt> S(2 * n);
        sort(all(V));

        for (int i = 0; i < n; ++i) {
            while (k >= 2 && S[k - 2].orient(S[k - 1], V[i]) < 0) {
                --k;
            }

            S[k++] = V[i];
        }

        for (int i = n - 2, l = k + 1; i >= 0; --i) {
            while (k >= l && S[k - 2].orient(S[k - 1], V[i]) < 0) {
                --k;
            }

            S[k++] = V[i];
        }

        S.resize(k - 1);
        V = S;
    }
};

const double PI = acos(-1.0);

double ans[105];

vector<pt> arr;

int n;

void solve() {
    scanf("%d", &n);
    vector<pair<pt, int>> vv;

    for (int i = 0; i < n; ++i) {
        pt p;
        p.read();
        arr.pb(p);
        vv.pb(mp(p, i));
    }

    sort(all(vv));

    convexHull T(arr);
    T.solve();
    arr = T.V;

    for (int i = 0; i < arr.size(); ++i) {
        pt p1 = (i ? arr[i - 1] : arr.back());
        pt p2 = arr[i];
        pt p3 = (i + 1 < arr.size() ? arr[i + 1] : arr.front());

        ll A = p2.distSq(p1);
        ll B = p2.distSq(p3);
        ll C = p1.distSq(p3);

        double alpha = acos((A + B - C) / (2.0 * sqrt(A) * sqrt(B)));
        int id = lower_bound(all(vv), mp(arr[i], 0)) -> se;
        ans[id] = (PI - alpha) / (2.0 * PI);
    }

    for (int i = 0; i < n; ++i) {
        printf("%.12f\n", ans[i]);
    }
}

int main() {
    int tt = 1;

    while (tt--) {
        solve();
    }

    return 0;
}

Measured memory_bytes: 256