//------------------------------>> tsukasa_diary's template <<------------------------------//
#include <bits/stdc++.h>
using namespace std;

#define for_(i,a,b) for(int i=(a);i<(b);++i)
#define for_rev(i,a,b) for(int i=(a);i>=(b);--i)
#define allof(a) (a).begin(),(a).end()
#define minit(a,b) memset(a,b,sizeof(a))

using lint = long long;
using pii = pair< int, int >;

template< typename T > using Vec = vector< T >;

template< typename T > bool in_range(T x, T lb, T ub) { return lb <= x && x < ub; }
template< typename T > bool in_range(T x, T y, T lb, T ub) { return in_range(x, lb, ub) && in_range(y, lb, ub); }

template< typename T > void modAdd(T& a, T b, T mod) { a = (a + b + mod) % mod; }
template< typename T > void modMul(T& a, T b, T mod) { a = (a * b) % mod; }
template< typename T > void minUpdate(T& a, T b) { a = min(a, b); }
template< typename T > void maxUpdate(T& a, T b) { a = max(a, b); }

int bitCount(int x) { return __builtin_popcount(x); }
int bitCount(lint x) { return __builtin_popcountll(x); }

const int dx[4] = {0,1,0,-1}, dy[4] = {-1,0,1,0};
const int Dx[8] = {0,1,1,1,0,-1,-1,-1}, Dy[8] = {-1,-1,0,1,1,1,0,-1};
const double EPS = 1e-9;
const double PI = acos(-1);

//--------------8---------------->> coding space <<-----------------8-------------//

struct Point {
	lint x, y;
	Point operator - (const Point& a) const { return Point{x - a.x, y - a.y}; }
	bool operator < (const Point& a) const { return x == a.x ? y < a.y : x < a.x; }
};

lint norm(const Point& a) { return a.x * a.x + a.y * a.y; }
double abs(const Point& a) { return sqrt((double)norm(a)); }
lint dot(const Point& a, const Point& b) { return a.x * b.x + a.y * b.y; }
lint cross(const Point& a, const Point& b) { return a.x * b.y - a.y * b.x; }

int ccw(const Point& a, const Point& b, const Point&  c) {
	Point ba = b - a, ca = c - a;
	if (cross(ba, ca) > 0) return +1; // ccw
	if (cross(ba, ca) < 0) return -1; // cw
	if (dot(ba, ca) < 0) return +2; // c-a-b
	if (norm(ba) < norm(ca)) return -2; // a-b-c
	return 0; // a-c-b
}

Vec< Point > convex_hull(Vec< Point > vp) {
	int n = vp.size(), k = 0;
	sort(allof(vp));
	Vec< Point > ch(2 * n);
	
	for (int i = 0; i < n; ch[k++] = vp[i++]) {
		while (k >= 2 && ccw(ch[k - 2], ch[k - 1], vp[i]) <= 0) --k;
	}
	
	for (int i = n - 2, t = k + 1; i >= 0; ch[k++] = vp[i--]) {
		while (k >= t && ccw(ch[k - 2], ch[k - 1], vp[i]) <= 0) --k;
	}
	
	ch.resize(k-1);
	return ch;
}

double calcCos(const Point& a, const Point& b, const Point& c) {
	Point x = b - a, y = c - a;
	return (double)dot(x, y) / abs(x) / abs(y);
}


int main() {
	int N;
	cin >> N;
	
	Vec< Point > vp;
	for_(i,0,N) {
		lint x, y;
		cin >> x >> y;
		vp.push_back(Point{x, y});
	}
	
	Vec< Point > convex = convex_hull(vp);
	int m = convex.size();
	
	Vec< int > convex_id(N, -1);
	for_(i,0,N) {
		const Point& pi = vp[i];
		for_(j,0,m) {
			const Point& pc = convex[j];
			if (pc.x == pi.x && pc.y == pi.y) {
				convex_id[i] = j;
				break;
			}
		}
	}
	
	for_(i,0,N) {
		//cerr << convex_id[i] << endl;
		if (convex_id[i] == -1) puts("0");
		else {
			if (m == 2) puts("0.5");
			else {
				int id = convex_id[i];
				double si = PI - acos(calcCos(convex[id], convex[(id+1)%m], convex[(id-1+m)%m]));
				cout << setprecision(20) << setiosflags(ios::fixed) << si / (2. * PI) << endl;
			}
		}
	}
}
//--------------8---------------->> coding space <<-----------------8-------------//

Measured memory_bytes: 256