#include<map>
#include<set>
#include<bitset>
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<string>
#include<chrono>
#include<stack>
#include<fstream>
#include<list>
#include<complex>
#define REP(i,x,y) for(ll i=x;i<=y;i++)
#define SIZE(a) ll(a.size())
#define vll vector<ll> 
#define MEMSET(a, n, m) for(ll i=0;i<=n;i++) a[i] = m
#define BIT(n) (ll(1)<<n)
#define UNIQUE(v) v.erase(unique(v.begin(),v.end()),v.end()) 
#define UNIQUE_ARRAY(a,x) unique(a + 1, a + x + 1) - a - 1
#define SORT(a,n) sort(a+1,a+n+1)
#define SORT_O(a,n,order) sort(a+1,a+n+1,order)
#define PER(i,y,x) for(ll i=y;i>=x;i--)
typedef long long ll;
using namespace std;


struct edge
{
	long long to; long long len;
	bool operator<(const edge& rhs) const {
		return len > rhs.len;
	}
};

ll const MOD = 1e9 + 7;
ll mod_p(ll x, ll y) {
	x %= MOD;
	y %= MOD;
	return (x + y + MOD) % MOD;
}

ll mod_m(ll x, ll y) {
	x %= MOD;
	y %= MOD;
	return x * y%MOD;
}

ll mod_pow(ll x, ll t) {
	x %= MOD;
	if (t == 0) {
		return 1;
	}
	else {
		ll v = mod_pow(x, t / 2);
		if (t % 2 == 0) {
			return v * v % MOD;
		}
		else {
			return v * v%MOD * x %MOD;
		}
	}
}

ll mod_inv(ll x) {
	return mod_pow(x, MOD - 2);
}

/*
#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <math.h>
#include <complex>
using namespace std;
*/
#define rep(i,n) for (int i=0; i < (n); i++)
typedef double D;      // 座標値の型。doubleかlong doubleを想定
typedef complex<D> P;  // Point
typedef pair<P, P> L;  // Line
typedef vector<P> VP;
const D EPS = 1e-9;    // 許容誤差。問題によって変える
#define X real()
#define Y imag()
#define LE(n,m) ((n) < (m) + EPS)
#define GE(n,m) ((n) + EPS > (m))
#define EQ(n,m) (abs((n)-(m)) < EPS)

					   // 内積　dot(a,b) = |a||b|cosθ
D dot(P a, P b) {
	return (conj(a)*b).X;
}
// 外積　cross(a,b) = |a||b|sinθ
D cross(P a, P b) {
	return (conj(a)*b).Y;
}

// 点の進行方向
int ccw(P a, P b, P c) {
	b -= a;  c -= a;
	if (cross(b, c) >  EPS) return +1;  // counter clockwise
	if (cross(b, c) < -EPS) return -1;  // clockwise
	if (dot(b, c)   < -EPS) return +2;  // c--a--b on line
	if (norm(b) < norm(c)) return -2;  // a--b--c on line or a==b
	return 0;                          // a--c--b on line or a==c or b==c
}

/* 交差判定　直線・線分は縮退してはならない。接する場合は交差するとみなす。isecはintersectの略 */

// 直線と点
bool isecLP(P a1, P a2, P b) {
	return abs(ccw(a1, a2, b)) != 1;  // return EQ(cross(a2-a1, b-a1), 0); と等価
}

// 直線と直線
bool isecLL(P a1, P a2, P b1, P b2) {
	return !isecLP(a2 - a1, b2 - b1, 0) || isecLP(a1, b1, b2);
}

// 直線と線分
bool isecLS(P a1, P a2, P b1, P b2) {
	return cross(a2 - a1, b1 - a1) * cross(a2 - a1, b2 - a1) < EPS;
}

// 線分と線分
bool isecSS(P a1, P a2, P b1, P b2) {
	return ccw(a1, a2, b1)*ccw(a1, a2, b2) <= 0 &&
		ccw(b1, b2, a1)*ccw(b1, b2, a2) <= 0;
}

// 線分と点
bool isecSP(P a1, P a2, P b) {
	return !ccw(a1, a2, b);
}


/* 距離　各直線・線分は縮退してはならない */

// 点pの直線aへの射影点を返す
P proj(P a1, P a2, P p) {
	return a1 + dot(a2 - a1, p - a1) / norm(a2 - a1) * (a2 - a1);
}

// 点pの直線aへの反射点を返す
P reflection(P a1, P a2, P p) {
	return 2.0*proj(a1, a2, p) - p;
}

D distLP(P a1, P a2, P p) {
	return abs(proj(a1, a2, p) - p);
}

D distLL(P a1, P a2, P b1, P b2) {
	return isecLL(a1, a2, b1, b2) ? 0 : distLP(a1, a2, b1);
}

D distLS(P a1, P a2, P b1, P b2) {
	return isecLS(a1, a2, b1, b2) ? 0 : min(distLP(a1, a2, b1), distLP(a1, a2, b2));
}

D distSP(P a1, P a2, P p) {
	P r = proj(a1, a2, p);
	if (isecSP(a1, a2, r)) return abs(r - p);
	return min(abs(a1 - p), abs(a2 - p));
}

D distSS(P a1, P a2, P b1, P b2) {
	if (isecSS(a1, a2, b1, b2)) return 0;
	return min(min(distSP(a1, a2, b1), distSP(a1, a2, b2)),
		min(distSP(b1, b2, a1), distSP(b1, b2, a2)));
}

// 2直線の交点
P crosspointLL(P a1, P a2, P b1, P b2) {
	D d1 = cross(b2 - b1, b1 - a1);
	D d2 = cross(b2 - b1, a2 - a1);
	if (EQ(d1, 0) && EQ(d2, 0)) return a1;  // same line
	if (EQ(d2, 0)) throw "kouten ga nai";   // 交点がない
	return a1 + d1 / d2 * (a2 - a1);
}


/* 多角形 */

// 頂点の順序（sortやmax_elementに必要）
namespace std {
	bool operator<(const P a, const P b) {
		return a.X != b.X ? a.X < b.X : a.Y < b.Y;
	}
}

// 凸包
VP convexHull(VP ps) {  // 元の点集合がソートされていいならVP&に
	int n = ps.size(), k = 0;
	sort(ps.begin(), ps.end());
	VP 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;  // 余計な点も含むなら == -1 とする
	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;
}

// 凸判定。縮退を認めないならccwの判定部分を != 1 とする
bool isCcwConvex(const VP& ps) {
	int n = ps.size();
	rep(i, n) if (ccw(ps[i], ps[(i + 1) % n], ps[(i + 2) % n]) == -1) return false;
	return true;
}

// 凸多角形の内部判定　O(n)
// 点が領域内部なら1、境界上なら2、外部なら0を返す
int inConvex(P p, const VP& ps) {
	int n = ps.size();
	int dir = ccw(ps[0], ps[1], p);
	rep(i, n) {
		int ccwc = ccw(ps[i], ps[(i + 1) % n], p);
		if (!ccwc) return 2;  // 線分上に存在
		if (ccwc != dir) return 0;
	}
	return 1;
}

// 凸多角形の内部判定　O(logn)
// 点が領域内部なら1、境界上なら2、外部なら0を返す
int inCcwConvex(const VP& ps, P p) {
	int n = ps.size();
	P g = (ps[0] + ps[n / 3] + ps[n * 2 / 3]) / 3.0;
	if (g == p) return 1;
	P gp = p - g;

	int l = 0, r = n;
	while (l + 1 < r) {
		int mid = (l + r) / 2;
		P gl = ps[l] - g;
		P gm = ps[mid] - g;
		if (cross(gl, gm) > 0) {
			if (cross(gl, gp) >= 0 && cross(gm, gp) <= 0) r = mid;
			else l = mid;
		}
		else {
			if (cross(gl, gp) <= 0 && cross(gm, gp) >= 0) l = mid;
			else r = mid;
		}
	}
	r %= n;
	D cr = cross(ps[l] - p, ps[r] - p);
	return EQ(cr, 0) ? 2 : cr < 0 ? 0 : 1;
}

// 多角形の内部判定
// 点が領域内部なら1、境界上なら2、外部なら0を返す
int inPolygon(const VP& ps, P p) {
	int n = ps.size();
	bool in = false;
	rep(i, n) {
		P a = ps[i] - p;
		P b = ps[(i + 1) % n] - p;
		if (EQ(cross(a, b), 0) && LE(dot(a, b), 0)) return 2;
		if (a.Y > b.Y) swap(a, b);
		if ((a.Y*b.Y < 0 || (a.Y*b.Y < EPS && b.Y > EPS)) && LE(cross(a, b), 0)) in = !in;
	}
	return in;
}

// 凸多角形クリッピング
VP convexCut(const VP& ps, P a1, P a2) {
	int n = ps.size();
	VP ret;
	rep(i, n) {
		int ccwc = ccw(a1, a2, ps[i]);
		if (ccwc != -1) ret.push_back(ps[i]);
		int ccwn = ccw(a1, a2, ps[(i + 1) % n]);
		if (ccwc * ccwn == -1) ret.push_back(crosspointLL(a1, a2, ps[i], ps[(i + 1) % n]));
	}
	return ret;
}

// 凸多角形の直径（最遠点対）
pair<int, int> convexDiameter(const VP& ps) {
	int n = ps.size();
	int i = min_element(ps.begin(), ps.end()) - ps.begin();
	int j = max_element(ps.begin(), ps.end()) - ps.begin();
	int maxI, maxJ;
	D maxD = 0;
	rep(_, 2 * n) {
		if (maxD < norm(ps[i] - ps[j])) {
			maxD = norm(ps[i] - ps[j]);
			maxI = i;
			maxJ = j;
		}
		if (cross(ps[i] - ps[(i + 1) % n], ps[(j + 1) % n] - ps[j]) <= 0) j = (j + 1) % n;
		else                                                      i = (i + 1) % n;
	}
	return make_pair(maxI, maxJ);
}

// 多角形の符号付面積
D area(const VP& ps) {
	D a = 0;
	rep(i, ps.size()) a += cross(ps[i], ps[(i + 1) % ps.size()]);
	return a / 2;
}

// 多角形の幾何学的重心
P centroid(const VP& ps) {
	int n = ps.size();
	D aSum = 0;
	P c;
	rep(i, n) {
		D a = cross(ps[i], ps[(i + 1) % n]);
		aSum += a;
		c += (ps[i] + ps[(i + 1) % n]) * a;
	}
	return 1 / aSum / 3 * c;
}

double degree(P a, P b, P c) {
	a -= b;
	c -= b;
	return arg(c / a);
}
double const PI = 3.1415926535;
ll const MAX = 1e3;
vector<P> v;
map<P, ll> mp;
double ans[MAX] = {};
int main() {
	cout.precision(13);
	ll n; cin >> n;
	REP(i, 1, n) {
		double x, y;
		cin >> x >> y;
		P z = x + y * 1i;
		v.push_back(z);
		mp[z] = i;
	}
	vector<P> ch;
	ch = convexHull(v);
	ch.push_back(ch[0]);
	ch.push_back(ch[1]);
	REP(i, 1, ch.size() - 2) {
		double dd = degree(ch[i - 1], ch[i], ch[i + 1]);
		dd = abs(dd);
		dd = (1 - dd / PI) / 2;
		ans[mp[ch[i]]] = dd;
	}
	REP(i, 1, n) {
		cout << ans[i] << endl;
	}


}

Measured memory_bytes: 512