#include <bits/stdc++.h>
using namespace std;

#define ALL(x) (x).begin(),(x).end() 
#define EACH(i,c) for(auto i=(c).begin();i!=(c).end();++i)

typedef long long ll;
const double eps = 1e-10;

const double PI = atan(1) * 4;
// 大小比較用
int sgn(double a){
    return a < -eps ? -1: a > eps ? 1: 0;
}
int sgn(double a, double b){
    return sgn(b - a);
}
typedef complex<double> P;
typedef vector<P> Polygon;
#define curr(p,i) p[i]
#define next(p,i) p[(i+1)%p.size()]
struct Line : public vector<P> {
    Line(P a, P b) {
        push_back(a); push_back(b);
    }
};
struct Segment : public Line {
    Segment(const P &a, const P &b) : Line(a,b) { }
};
struct Circle{
    P o;
    double r;
    Circle() { }
    Circle(const P &o, double r) : o(o), r(r) { }
    Circle(double x, double y, double r) : o(x,y), r(r) { }
	// 点の包含（境界を含む）
    bool contains(const P &p) const{
        return sgn(abs(p-o), r) <= 0;
    }
	// 内部（境界を含まず）
    bool inside(const P &p) const{
        return sgn(abs(p-o), r) < 0;
    }
	// 点pを通る接線．pからoへ向かうベクトルの左側がfirstに入る
    pair<Line,Line> tangent(const P &p) const{
        vector<Line> res;
        double d = abs(p - o), s = r*r / d, t = sqrt(r*r-s*s);
        P q = o + s/d * (p - o), e = (p - o) * P(0, 1/d); 
        return make_pair(Line(p,q+e*t), Line(p,q-e*t));
    }
};
 
bool near(const P &a, const P &b){
    return !sgn(abs(a-b));
}
// sort用．ClosestPair用にX,Yに分けている
bool lessX(const P &a, const P &b){
    if(sgn(real(a), real(b))) return real(a) < real(b);
    if(sgn(imag(a), imag(b))) return imag(a) < imag(b);
    return false;
}
bool lessY(const P &a, const P &b){
    if(sgn(imag(a), imag(b))) return imag(a) < imag(b);
    if(sgn(real(a), real(b))) return real(a) < real(b);
    return false;
}
double dot(const P &a, const P &b){
    return real(conj(a) * b);
}
double cross(const P &a, const P &b){
    return imag(conj(a) * b);
}
int ccw(const P &a, P b, P c){
    assert(!near(a, b));
    b -= a; c -= a;
    if (sgn(cross(b, c)) > 0)        return +1;  // ccw
    if (sgn(cross(b, c)) < 0)        return -1;  // cw
    if (sgn(dot(b, c)) < 0)          return +2;  // c-a-b
    if (sgn(norm(b), norm(c)) > 0)   return -2;  // a-b-c
    return 0;                                   // a-c-b
}
bool parallel(const Line &s, const Line &t){
    return !sgn(abs(cross(s[1]-s[0], t[1]-t[0])));
}
bool orthogonal(const Line &s, const Line &t){
    return !sgn(abs(dot(s[1]-s[0], t[1]-t[0])));
}
// 点aの直線s上への射影
P projection(const Line &s, const P &a){
    P v = s[1] - s[0];
    return s[0] + dot(v, a - s[0]) / abs(v) / abs(v) * v;
}
// 直線sに対する点aの鏡映
P reflection(const Line &s, const P &a){
    P p = projection(s, a);
    return 2.0 * p - a;
}

// 依存：geometry
bool intersectSS(const Segment &s, const Segment &t){
    return  ccw(s[0],s[1],t[0]) * ccw(s[0],s[1],t[1]) <= 0 &&
            ccw(t[0],t[1],s[0]) * ccw(t[0],t[1],s[1]) <= 0;
}
// TODO:端点の扱いが雑なのを何とかする
P crosspointSS(const Segment &s, const Segment &t){
    double a = cross(s[1] - s[0], t[1] - t[0]);
    double b = cross(s[1] - s[0], s[1] - t[0]);
    if(!sgn(abs(a)) && !sgn(abs(b))) return s[0];   // same line
    // if(abs(a) < eps) assert(false);
    return t[0] + b/a * (t[1] - t[0]);
}
P crosspointLL(const Line &s, const Line &t){
    double a = cross(s[1] - s[0], t[1] - t[0]);
    double b = cross(s[1] - s[0], s[1] - t[0]);
    if(!sgn(abs(a)) && !sgn(abs(b))) return s[0];   // same line
    // if(abs(a) < eps) assert(false);
    return t[0] + b/a * (t[1] - t[0]);
}
// 直線と点の距離
double distanceLP(const Line &s, const P &p){
    return abs(cross(p-s[0],s[1]-s[0])) / abs(s[1]-s[0]);
}
// 線分と点の距離
double distanceSP(const Segment &s, const P &p){
    if(min(dot(s[1]-s[0], p-s[0]), dot(s[0]-s[1], p-s[1])) < 0)
        return min(abs(p-s[0]), abs(p-s[1]));
    else
        return distanceLP(s, p);
 
}
// 線分と線分の距離
double distanceSS(const Segment &s, const Segment &t){
    if(intersectSS(s, t)) return 0;
    return min( min(distanceSP(s, t[0]), distanceSP(s, t[1])),
                min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}
// 円と円の交点（aからbへ向かう左側がfirst）
pair<P,P> crosspointCC(const Circle &a, const Circle &b){
    double d = abs(b.o - a.o);
    double x = (a.r * a.r - b.r * b.r + d * d) / (d * 2);
    P v = (b.o - a.o) * (1.0 / d);
    P n = P(0,1) * v;
    double h = sqrt(a.r * a.r - x * x);
    return make_pair(a.o + v * x + n * h,
                     a.o + v * x - n * h);
}
// 直線と円の交点の個数
// 交点の個数を返す
int intersectLC(const Line &l, const Circle &c){
    double d = distanceLP(l, c.o);
    return sgn(d, c.r) + 1;
}
// 直線と円の交点
// 直線が中心を通らない場合は，中心から直線へ向かう左側から．
// 通る場合は，中心から(l[1]-l[0])に向かう向きが先．
vector<P> crosspointLC(const Line &l, const Circle &c){
    int n = intersectLC(l, c);
    vector<P> res;
    if(!n) return res;
    P p = projection(l, c.o), e = 1.0/abs(l[1]-l[0])*(l[1]-l[0]);
    if(n == 1){
        res.push_back(p); return res;
    }
	if(sgn(abs(p - c.o)))
		e = (p - c.o) * P(0, 1/abs(p - c.o));
    double d = sqrt(c.r*c.r-norm(p-c.o));
    res.push_back(p + e * d);
    res.push_back(p - e * d);
    return res;
}

// 左側切除
Polygon convex_cut(const Polygon &p, const Line &l){
    Polygon res;
    for(int i = 0; i < p.size(); ++i){
		P a = curr(p,i), b = next(p,i);
        Line tl = Line(a, b);
        if(ccw(l[0], l[1], a) != -1) res.push_back(a);
        if(ccw(l[0], l[1], a) * ccw(l[0], l[1], b) < 0)
            res.push_back(crosspointLL(tl, l));
    }
    return res;
}

Polygon convex_hull(vector<P> ps, int strict=1){
    int n = ps.size(), k = 0;
    sort(ALL(ps), lessX);
    Polygon qs(n*2);
    for(int i = 0; i < n; qs[k++] = ps[i++])
        while(k > 1 && (ccw(qs[k-2], qs[k-1], ps[i]) & 7) > 6-strict) --k;
    for(int i = n-2, t=k; i >= 0; qs[k++] = ps[i--])
        while(k>t && (ccw(qs[k-2],qs[k-1], ps[i]) & 7) > 6-strict) --k;
    qs.resize(k-1);
    return qs;
}

Line func(P a, P b) {
	P m = (a + b) * 0.5, v = (b - a) * P(0, 1);

	return Line(m, m + v);
}

void solve(long long N, vector<long long> x, vector<long long> y){
	vector<P> p(N);
	vector<double> res(N);
	for(int i = 0; i < N; ++i) {
		p[i] = P(x[i], y[i]);
	}

	Polygon Q = convex_hull(p);
	int M = Q.size();
	for(int i = 0; i < Q.size(); ++i) {
		P a = Q[(i + M - 1) % M], b = Q[i], c = Q[(i + 1) % M];

		Line l1 = func(b, a), l2 = func(c, b);
		P v = l1[1] - l1[0], u = l2[1] - l2[0];
		double d1 = atan2(v.imag(), v.real());
		double d2 = atan2(u.imag(), u.real());
		if(d2 < d1) d2 += 2 * PI;
		double ar = d2 - d1;
		for(int j = 0; j < N; ++j) {
			if(abs(b - p[j]) < eps) {
				res[j] = ar / (2 * PI);
			}
		}
	}

	for(int i = 0; i < N; ++i) {
		printf("%.10f\n", res[i]);
	}
}

int main(){	
	long long N;
	scanf("%lld",&N);
	vector<long long> y(N-1+1);
	vector<long long> x(N-1+1);
	for(int i = 0 ; i <= N-1 ; i++){
		scanf("%lld",&x[i]);
		scanf("%lld",&y[i]);
	}
	solve(N, x, y);
	return 0;
}



Measured memory_bytes: 384