#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<math.h>
#include<iomanip>
#include<set>
#include<numeric>
#include<cstring>
#include<cstdio>
#include<functional>

#define REP(i, n) for(int i = 0;i < n;i++)
#define REPR(i, n) for(int i = n;i >= 0;i--)
#define FOR(i, m, n) for(int i = m;i < n;i++)
#define FORR(i, m, n) for(int i = m;i >= n;i--)
#define SORT(v, n) sort(v, v+n);
#define VSORT(v) sort(v.begin(), v.end());
#define REVERSE(v,n) reverse(v,v+n);
#define VREVERSE(v) reverse(v.begin(), v.end());
#define ll long long
#define pb(a) push_back(a)
#define m0(x) memset(x,0,sizeof(x))
//#define fill(x,y) memset(x,y,sizeof(x))
#define print(x) cout<<x<<endl;
#define pe(x) cout<<x<<" ";
#define lb(v,n) lower_bound(v.begin(), v.end(), n);
#define ub(v,n) upper_bound(v.begin(), v.end(), n);
#define int long long


using namespace std;
//typedef pair<int, int>P;

int dy[4] = { 0,0,1,-1 };
int dx[4] = { 1,-1,0,0 };
int dxx[8] = { 0,0,1,1,1,-1,-1,-1 };
int dyy[8] = { 1,-1,0,1,-1,0,1,-1 };


const int MAX = 500010;
const int MOD = 1000000007;
const ll INF = 10e17;
const double pi = acos(-1);


double EPS = 1e-10;
double add(double a, double b) {
	if(fabs(a+b)<EPS*(fabs(a)+fabs(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 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);
	for (int i = 0; i < n; i++) {
		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;
}
P ps[MAX];

double angle(P a, P b, P c) {
	double x1 = b.x - a.x, x2 = c.x - a.x;
	double y1 = b.y - a.y, y2 = c.y - a.y;
	double dt = x1 * x2 + y1 * y2;
	return acos(dt / (sqrt(x1*x1 + y1 * y1)*sqrt(x2*x2 + y2 * y2)));
	/*double tan1 = y1 / x1, tan2 = y2 / x1;
	if (atan(tan1) > atan(tan2)) {
		return atan((tan1 - tan2) / (1 + tan1 * tan2));
	}
	else return atan((tan2 - tan1) / (1 + tan1 * tan2));*/
}

double ans[1000];
double x[1000], y[1000];
signed main() {
	P a = { 0,0 }, b = { 0,-1}, c = { -1,1 };
	//print(angle(a, b, c));
	int N; cin >> N;
	
	REP(i, N) {
		cin >> x[i] >> y[i];
		ps[i] = { x[i],y[i] };
	}

	if (N == 2) {
		print(0.5);
		print(0.5);
		return 0;
	}

	REP(i, 1000)ans[i] = 0;
	vector<P> qs = convex_hull(ps, N);

	for (auto a : qs) {
		//pe(a.x); print(a.y);
	}

	for (int i = 0; i < N;i++) {
		P a = { x[i],y[i] };
		bool found = false;
		for (auto p : qs) {
			if (a.x == p.x&&a.y == p.y) {
				found = true; break;
			}
		}
		if (!found)continue;
		double ang = 0;
		for (auto b : qs) {
			for (auto c : qs) {
				if ((a.x == b.x&&a.y == b.y) || (b.x == c.x&&b.y == c.y) || (c.x == a.x&&c.y == a.y))continue;
				//print(angle(a, b, c));
				ang = max(ang, angle(a, b, c));
			}
		}

		ans[i] = (pi - ang) / (2 * pi);
	}
	REP(i, N) {
		cout << setprecision(20) << ans[i] << endl;
	}
}

Measured memory_bytes: 512