#include "bits/stdc++.h"
using namespace std;
#define ll long long int
#define rep(i,n) for( int i = 0; i < n; i++ )
#define rrep(i,n) for( int i = n; i >= 0; i-- )
#define REP(i,s,t) for( int i = s; i <= t; i++ )
#define RREP(i,s,t) for( int i = s; i >= t; i-- )
#define dump(x)  cerr << #x << " = " << (x) << endl;
#define INF 2000000000
#define mod 1000000007
#define INF2 1000000000000000000
#define PI 3.141592653589793238

double EPS = 1e-9;

// 誤差を考慮して足し算を行う
double add(double a, double b) {
    if (abs(a + b) < EPS * (abs(a) + abs(b))) return 0;
    return a + b;
}


struct P {
    double x, y;
    P() {}
    P(double x, double y) : x(x), y(y) {
    }
    P operator + (P p) {
        return P(add(x, p.x), add(y, p.y));
    }
    P operator - (P p) {
        return P(add(x, -p.x), add(y, -p.y));
    }    
    P operator * (double d) {
        return P(x * d, y * d);
    }
    double dot(P p) {   // 内積
        return add(x * p.x, y * p.y);
    }
    double det(P p) {   // 外積
        return add(x * p.y, -y * p.x);
    }
    bool operator<(const P& value) const
    {
        if (x != value.x) return x < value.x;
        return y < value.y;
    }
};

bool cmp_x(const P& p, const P& q) {
    if (p.x != q.x) return p.x < q.x;
    return p.y < q.y;
}


// 凸包を求める
vector<P> convex_hull(P* ps, int n) {
    sort(ps, ps + n, cmp_x);
    int k = 0;                  // 凸包の頂点数
    vector<P> qs(n * 2);        // 構想中の凸包

    // 下側凸包の作成
    rep(i, n) {
        while (k > 1 && (qs[k - 1] - qs[k - 2]).det(ps[i] - qs[k - 1]) <= 0) k--;
        qs[k++] = ps[i];
    }

    // 上側凸包の作成
    for (int i = n - 2, t = k; i >= 0; i--) {
        while (k > t && (qs[k - 1] - qs[k - 2]).det(ps[i] -qs[k - 1]) <= 0) k--;
        qs[k++] = ps[i];
    }
    qs.resize(k - 1);
    return qs;
}

double dist(P p, P q) {
    return (p - q).dot(p - q);
} 

struct Vector2D{
	double x;
	double y;
};

//ベクトルの長さを計算する
double get_vector_length( Vector2D v ) {
	return pow( ( v.x * v.x ) + ( v.y * v.y ), 0.5 );
}

//ベクトル内積
double dot_product(Vector2D vl, Vector2D vr) {
	return vl.x * vr.x + vl.y * vr.y;
}

//２つのベクトルABのなす角度θを求める
double AngleOf2Vector(Vector2D A, Vector2D B )
{
	//　※ベクトルの長さが0だと答えが出ませんので注意してください。

	//ベクトルAとBの長さを計算する
	double length_A = get_vector_length(A);
	double length_B = get_vector_length(B);

	//内積とベクトル長さを使ってcosθを求める
	double cos_sita = dot_product(A,B) / ( length_A * length_B );

	//cosθからθを求める
	double sita = acos( cos_sita );	

	//ラジアンでなく0～180の角度でほしい場合はコメント外す
	//sita = sita * 180.0 / PI;

	return sita;
}
P pp[100010];
P original[100010];
int main(void)
{
    cin.tie(0);
    ios::sync_with_stdio(false);
    int n; cin >> n;
    rep(i, n) {
        cin >> pp[i].x >> pp[i].y;
        original[i] = pp[i];
    }
    vector<P> p;
    map<P, double> ans;
    p = convex_hull(pp, n);
    int cnt = p.size();
    rep(i, p.size()) {
        //cout << p[i].x << " " << p[i].y << endl;
        int prev = ((i - 1) + cnt) % cnt;
        int next = (i + 1) % cnt;
        Vector2D first, second;
        first.x = p[prev].x - p[i].x;
        first.y = p[prev].y - p[i].y;
        second.x = p[next].x - p[i].x;
        second.y = p[next].y - p[i].y;
        ans[p[i]] = (PI - AngleOf2Vector(first, second))/(2*PI);
        //cout << (PI - AngleOf2Vector(first, second))/(2*PI) << endl;
    }
    if (cnt == 2) {
        rep(i, 2) ans[p[i]] = 0.5;
    }
    rep(i, n) {
        //cout << original[i].x << " " << original[i].y << ":";
        cout << fixed << setprecision(12) << ans[original[i]] << endl;
    }
    


    return 0;
}


Measured memory_bytes: 256