#include "bits/stdc++.h"
using namespace std;
const int maxn = 100100;
const int magic = 333;
typedef complex<double> point;
const double E = 1e-9, pi = 2 * acos(0);
struct line{
    point p, v;
};
struct seg{
    point a, b;
    line toline(){
        return {a, b - a};
    }
};
int sign(double x){
    if(x < -E) return -1;
    if(x >  E) return 1;
    return 0;
}
double cross(point a, point b){
    return a.real() * b.imag() - a.imag() * b.real();
}
double cross(point a, point b, point c){
    return cross(b-a, c-a);
}
double dot(point a, point b){
    return a.real() * b.real() + a.imag() * b.imag();
}
double dot(point a, point b, point c){
    return dot(b-a, c-a);
}
bool xycmp(point a, point b){
    if(abs(a.real() - b.real()) > E) return a.real() < b.real();
    if(abs(a.imag() - b.imag()) > E) return a.imag() < b.imag();
    return false;
}
bool yxcmp(point a, point b){
    if(abs(a.imag() - b.imag()) > E) return a.imag() < b.imag();
    if(abs(a.real() - b.real()) > E) return a.real() < b.real();
    return false;
}
point proj(point a, point v){
    return v * dot(a, v) / dot(v, v);
}
int side(seg x, point a){
    return sign(cross(x.a, x.b, a));
}
bool segcross(seg x, seg y){ // True if they are not parallel and strictly cross
    return side(x, y.a) * side(x, y.b) < 0 && side(y, x.a) * side(y, x.b) < 0;
}
bool segtouch(seg x, seg y){ // True if their intersection is non empty
    bool res = side(x, y.a) * side(x, y.b) <= 0 && side(y, x.a) * side(y, x.b) <= 0;
    if(res && sign(cross(x.b - x.a, y.b - y.a)) == 0){
        res &= !(dot(x.a, x.b, y.a) < -E && dot(x.a, x.b, y.b) < -E);
        res &= !(dot(x.b, x.a, y.a) < -E && dot(x.b, x.a, y.b) < -E);
    }
    return res;
}
point closest(point p, line l){
    return l.p + proj(p - l.p, l.v);
}
point closest(point p, seg x){
    point v = x.b - x.a; double m = dot(p - x.a, v) / dot(v, v);
    if(m < 0) m = 0;
    if(m > 1) m = 1;
    return x.a + m * v;
}
point intersection(line x, line y){
    double t = cross(y.p - x.p, y.v) / cross(x.v, y.v);
    return x.p + x.v * t;
}
point circumcenter(point a, point b, point c){
    if(sign(cross(a, b, c)) == 0){
        if(norm(a - b) > norm(a - c) && norm(a - b) > norm(b - c)) return (a + b)/2.;
        if(norm(a - c) > norm(b - c)) return (a + c)/2.;
        return (b + c)/2.;
    }
    point x = (b + a)/2., dirx = (a - b) * point(0, 1);
    point y = (b + c)/2., diry = (c - b) * point(0, 1);
    return intersection((line){x, dirx}, (line){y, diry});
}
pair<point, double> minimum_covering_circle(vector<point> points){
    random_shuffle(points.begin(), points.end());
    point C;
    double rad = -10;
    for(int i = 0; i < (int)points.size(); ++i)
        if(abs(points[i] - C) > rad + E){
            C = points[i]; rad = 0.0;
            for(int j = 0; j < i; ++j)
                if(abs(points[j] - C) > rad + E){
                    C = (points[i] + points[j])/2.;
                    rad = abs(points[i] + points[j])/2.;
                    for(int k = 0; k < j; ++k)
                        if(abs(points[k] - C) > rad + E){
                            C = circumcenter(points[i], points[j], points[k]);
                            rad = abs(C - points[i]);
                        }
                }
        }
    return {C, rad};
}
vector<point> convex_hull(vector<point> points){
    sort(points.begin(), points.end(), xycmp);
    vector<point> upper, lower;
    for(int i = 0; i < (int)points.size(); ++i){
        while(upper.size() >= 2 && cross(upper.end()[-2], upper.end()[-1], points[i]) >= E)
            upper.pop_back();
        upper.push_back(points[i]);
    }
    for(int i = (int)points.size()-1; i >= 0; --i){
        while(lower.size() >= 2 && cross(lower.end()[-2], lower.end()[-1], points[i]) >= E)
            lower.pop_back();
        lower.push_back(points[i]);
    }
    if(lower.size() > 2) upper.insert(upper.end(), lower.begin() + 1, lower.end() - 1);
    return upper;
}
// 1 => Strictly inside; -1 => Border; 0 => Outside
int point_in_poly(const vector<point> & poly, point p){
    int many = 0;
    for(int i = 0; i < (int)poly.size(); ++i){
        point a = poly[i], b = poly[i + 1 < (int) poly.size() ? i + 1 : 0];
        if(a.real() > b.real()) swap(a, b);
        if(a.real()-E <= p.real() && p.real() <= b.real()+E){
            if(abs(a.real() - b.real()) <= E){
                double y0 = min(a.imag(), b.imag()), y1 = max(a.imag(), b.imag());
                if(y0 - E <= p.imag() && p.imag() <= y1 + E) return -1;
            } else {
                double y = a.imag() + (b.imag() - a.imag())/(b.real() - a.real())*(p.real() - a.real());
                if(abs(y - p.imag()) <= E) return -1;
                if(y >= p.imag() && p.real() < b.real() - E) ++ many;
            }
        }
    }
    return many % 2;
}
int main(){
    vector<point> d, u;
    int n; cin >> n;
    vector<double> ans(n, 0);
    map<pair<int,int>, int> iden;
    for(int e = 0; e < n; e++){
        int x, y; cin >> x >> y;
        d.push_back(point(x, y));
        iden[{x,y}] = e;
    }
    u = d;
    d = convex_hull(d);
    for(int e = 0; e < d.size(); e++){
        point a = d[e];
        point b = d[(e+1)%d.size()];
        point c = d[(e+d.size()-1)%d.size()];
        double crs = dot(a, b, c)/abs(b-a)/abs(c-a);
        double theta = acos(max(crs, double(-1)));
        ans[iden[{(int)a.real(), (int)a.imag()}]] = (pi - theta)/(2*pi);
    }
    for(int e = 0; e < n; e++)
        cout << fixed << setprecision(20) << ans[e] << endl;
    return 0;
}


Measured memory_bytes: 256