#include <bits/stdc++.h>

#ifndef LOCAL
#define cerr dolor_sit_amet
#endif

#define mp make_pair
#define sz(x) ((int)((x).size()))
#define X first
#define Y second
#define ALL(x) (x).begin(), (x).end()

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair < int , int > ipair;
typedef pair < ll , ll > lpair;
const int IINF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3fll;
const double DINF = numeric_limits<double>::infinity();
const int MOD = 1000000007;
const double EPS = 1e-9;
const ld PI = acos((ld)(-1.0));
const int DX[] = { 1,  0, -1,  0,  1, -1,  1, -1};
const int DY[] = { 0,  1,  0, -1,  1, -1, -1,  1};
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll sqr(ll x) { return x*x; } ll sqr(int x) { return (ll)x*x; }
double sqr(double x) { return x*x; } ld sqr(ld x) { return x*x; }
mt19937 mmtw(960172);
ll rnd(ll x, ll y) { static uniform_int_distribution<ll> d; return d(mmtw) % (y - x + 1) + x; }

// ========================================================================= //

const int N = 100179;

struct Vec2
{
	ll x, y;
	
	Vec2() {}
	Vec2(ll nx, ll ny) : x(nx), y(ny) {}

	Vec2 operator + (const Vec2 & b) const { return { x+b.x, y+b.y }; }
	Vec2 operator - (const Vec2 & b) const { return { x-b.x, y-b.y }; }
	Vec2 operator - () const { return { -x, -y }; }
	Vec2 operator * (ll b) const { return { x*b, y*b }; }

	Vec2 & operator += (const Vec2 & b) { x+=b.x; y+=b.y; return *this; }
	Vec2 & operator -= (const Vec2 & b) { x-=b.x; y-=b.y; return *this; }
	Vec2 & operator *= (ll b) { x*=b; y*=b; return *this; }

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

istream & operator >> (istream & in, Vec2 & v) { return in >> v.x >> v.y; }
ostream & operator << (ostream & out, const Vec2 & v) { return out << v.x << " " << v.y; }
Vec2 operator * (ll b, const Vec2 & a) { return { b*a.x, b*a.y }; }
ll dot(const Vec2 & a, const Vec2 & b) { return a.x*b.x + a.y*b.y; }
ll cross(const Vec2 & a, const Vec2 & b) { return a.x*b.y - a.y*b.x; }
ll length2(const Vec2 & a) { return a.x*a.x + a.y*a.y; }
ld length(const Vec2 & a) { return sqrt((ld)a.x*a.x + a.y*a.y); }

int main() {
    ios::sync_with_stdio(false);
    
    int n;
    cin >> n;
    vector<pair<Vec2, int>> p(n);
    for (int i = 0; i < n; ++i) {
        cin >> p[i].X;
        p[i].Y = i;
    }
    swap(p[0], *min_element(ALL(p)));
    for (int i = n - 1; i >= 0; --i)
        p[i].X -= p[0].X;
    sort(ALL(p), [&](pair<Vec2, int> p1, pair<Vec2, int> p2) {
        Vec2 v1 = p1.X, v2 = p2.X;
        ll c = cross(v1, v2);
        if (c == 0)
            return length2(v1) < length2(v2);
        return c > 0;
    });

    vector<pair<Vec2, int>> ch;
    for (auto pp : p) {
        Vec2 v = pp.X;
        while (true) {
            if (sz(ch) < 2)
                break;
            Vec2 v1 = ch[sz(ch) - 2].X;
            Vec2 v2 = ch[sz(ch) - 1].X;
            if (cross(v2 - v1, v - v1) > 0)
                break;
            ch.pop_back();
        }
        ch.push_back(pp);
    }

    vector<ld> ans(n, 0.0);
    for (int i = 0; i < sz(ch); ++i) {
        Vec2 pp = ch[i].X;
        Vec2 p1 = ch[(i+sz(ch)-1)%sz(ch)].X;
        Vec2 p2 = ch[(i+1)%sz(ch)].X;
        ld ang = acos(min<ld>(1.0, max<ld>(-1.0, dot(pp - p1, p2 - pp) / length(pp - p1) / length(p2 - pp))));
        ans[ch[i].Y] = ang / (2*PI);
    }

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

    return 0;
}


Measured memory_bytes: 256