#include <iostream>
#include <cstdio>
#include <vector>
#define _USE_MATH_DEFINES
#include <math.h>
#include <cstring>
#include <numeric>
#include <algorithm>
#include <stdlib.h>
#include <functional>
#include <string>
#include <list>
#include <fstream>
#include <iomanip>
#include <array>
#include <map>
#include <queue>
#include <limits.h>
#include <set>
#include <stack>
#include <random>
#include <complex>
#include <unordered_map>
#include <unordered_set>
#include <chrono>
#define rep(i,s,n) for(int i = (s); (n) > i; i++)
#define REP(i,n) rep(i,0,n)
#define RANGE(x,a,b) ((a) <= (x) && (x) <= (b))
#define DUPLE(a,b,c,d) (RANGE(a,c,d) || RANGE(b,c,d) || RANGE(c,a,b) || RANGE(d,a,b))
#define INCLU(a,b,c,d) (RANGE(a,c,d) && (b,c,d))
#define PW(x) ((x)*(x))
#define ALL(x) (x).begin(), (x).end()
#define MODU 1000000007
#define bitcheck(a,b)   ((a >> b) & 1)
#define bitset(a,b)      ( a |= (1 << b))
#define bitunset(a,b)    (a &= ~(1 << b))
#define MP(a,b) make_pair((a),(b))
#define Manh(a,b) (abs((a).first-(b).first) + abs((a).second - ((b).second))
#define pritnf printf
#define scnaf scanf
#define itn int
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
ll gcd(ll a, ll b) {
	if (b == 0) return a;
	return gcd(b, a%b);
}
template<typename A, size_t N, typename T>
void Fill(A(&array)[N], const T &val) {
	std::fill((T*)array, (T*)(array + N), val);
}

struct Edge {
	int from, to;
};
////テンプレ////
const double EPS = 1e-8;
const double INF = 1e12;
typedef complex<double> Pt;//点
namespace std {
	bool operator < (const Pt& a, const Pt& b) {
		return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
	}
}
double cross(const Pt& a, const Pt& b) {
	return imag(conj(a)*b);
}
double dot(const Pt& a, const Pt& b) {
	return real(conj(a)*b);
}

struct Ln : public vector<Pt> {//線
	Ln(const Pt &a, const Pt &b) {
		push_back(a); push_back(b);
	}
};

typedef vector<Pt> Pol;//多角形
#define prev(P, i) P[(i-1 + P.size())%P.size()]
#define curr(P, i) P[(i)%P.size()]
#define next(P, i) P[(i+1)%P.size()]

int ccw(Pt a, Pt b, Pt c) {
	b -= a; c -= a;
	if (cross(b, c) > 0)   return +1;       // counter clockwise
	if (cross(b, c) < 0)   return -1;       // clockwise
	if (dot(b, c) < 0)     return +2;       // c--a--b on line
	if (norm(b) < norm(c)) return -2;       // a--b--c on line
	return 0;
}
////////////////
Pol convex_hull(vector<Pt> ps) {
	int n = ps.size(), k = 0;
	sort(ps.begin(), ps.end());
	vector<Pt> ch(2 * n);
	for (int i = 0; i < n; ch[k++] = ps[i++]) // lower-hull
		while (k >= 2 && ccw(ch[k - 2], ch[k - 1], ps[i]) <= 0) --k;
	for (int i = n - 2, t = k + 1; i >= 0; ch[k++] = ps[i--]) // upper-hull
		while (k >= t && ccw(ch[k - 2], ch[k - 1], ps[i]) <= 0) --k;
	ch.resize(k - 1);
	return ch;
}
Pt crosspoint(const Ln &l, const Ln &m) {
	double A = cross(l[1] - l[0], m[1] - m[0]);
	double B = cross(l[1] - l[0], l[1] - m[0]);
	if (abs(A) < EPS && abs(B) < EPS) return m[0]; // same line
	return m[0] + B / A * (m[1] - m[0]);
}

double distancePP(const Pt &p, const Pt &q) {
	return hypot(p.real() - q.real(), p.imag() - q.imag());
}
int main() {
	int n;

	cin >> n; 
	vector<Pt> po(n);

	REP(i, n) {
		int a, b;
		scanf("%d %d", &a, &b);
		po[i] = {(double)a,(double)b};
	}
	Pol pol = convex_hull(po);
	map<Pt, int> ind;
	REP(i, pol.size())
		ind[pol[i]] = i;
	vector<double> kaku;
	double sum = 0;
	REP(i, n) {
		Pt sui[2];
		sui[0] = (prev(pol, i) + curr(pol,i));
		sui[0] /= 2;
		sui[1] = (next(pol, i) + curr(pol, i));
		sui[1] /= 2;

		double la, lb, lc;
		lc = distancePP(sui[0], curr(pol, i));
		lb = distancePP(sui[1], curr(pol, i));
		la = distancePP(sui[0], sui[1]);
		kaku.push_back(M_PI - acos((PW(lb) + PW(lc) - PW(la)) / (2 * lb * lc)));
		sum += kaku.back();
	}

	REP(i, n) {
		if (ind.count(po[i])) {
			cout << kaku[ind[po[i]]]/(2*M_PI) << endl;
		}
		else {
			cout << 0 << endl;
		}
	}

	return 0;
}

Measured memory_bytes: 256