#include <bits/stdc++.h>
#define rep(i, n) for(int i=0; i<(n); i++)
#define int long long
#define double long double
#define all(a) a.begin(),a.end()
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
using namespace std;

const double inf = 1e18;
const double eps = 1e-10;
const double pi = acos(-1.0);
double torad(double deg){return deg*pi/180;}
double todeg(double rad){return rad*180/pi;}


struct Point{
    double x,y;
    Point(double x = 0.0, double y = 0.0):x(x),y(y){}
};

inline Point operator+(Point p, Point q){return Point(p.x+q.x,p.y+q.y);}
inline Point operator-(Point p, Point q){return Point(p.x-q.x,p.y-q.y);}
inline Point operator*(Point p, double a){return Point(p.x*a,p.y*a);}
inline Point operator*(double a, Point p){return Point(p.x*a,p.y*a);}
inline Point operator/(Point p, double a){return Point(p.x/a,p.y/a);}
inline Point toPoint(double rad, double abs){return Point(cos(rad),sin(rad))*abs;}
inline Point rot(Point p, double rad){return Point(cos(rad)*p.x-sin(rad)*p.y,sin(rad)*p.x+cos(rad)*p.y);}
inline Point rot90(Point p){return Point(-p.y,p.x);}
inline double norm(Point p){return p.x*p.x+p.y*p.y;}
inline double abs(Point p){return sqrt(norm(p));}
inline double cross(Point p, Point q){return p.x*q.y-p.y*q.x;}
inline double dot(Point p, Point q){return p.x*q.x+p.y*q.y;}
inline double amp(Point p){double rad=atan2(p.y,p.x); if(rad<0)rad+=pi*2; return rad;}
inline bool operator<(Point p, Point q){return abs(p.x-q.x)<eps?p.y<q.y:p.x<q.x;}
inline bool operator>(Point p, Point q){return abs(p.x-q.x)<eps?p.y>q.y:p.x>q.x;}
inline bool operator==(Point p, Point q){return abs(p.x-q.x)<eps and abs(p.y-q.y)<eps;}


struct Line{
    Point start,end;
    Line(Point p=Point(0.0, 0.0), Point q=Point(0.0, 0.0)):start(p),end(q){}
};

inline Point vect(Line l){return Point(l.end.x-l.start.y,l.end.y-l.start.x);}
inline double length(Line l){return abs(vect(l));}
inline bool parallel(Line l, Line m){return abs(cross(vect(l),vect(m)))<eps;}
inline bool vertical(Line l, Line m){return abs(dot(vect(l),vect(m)))<eps;}

bool intersect(Line l, Line m, bool endp){
    double t1=cross(vect(l),Point(m.start-l.start));
    double t2=cross(vect(l),Point(m.end-l.start));
    double t3=cross(vect(m),Point(l.start-l.start));
    double t4=cross(vect(m),Point(l.end-m.start));
    return endp?(t1*t2<=0 and t3*t4<=0):(t1*t2<0 and t3*t4<0);
}

vector<int> ConvexHull(vector<Point> points, bool edges){
    int size=points.size(),num=0; 
    vector<int> order(size),res(size*2); iota(all(order),0);
    sort(all(order),[&](int i, int j){return points[i]<points[j];});
    auto check=[&](int i, int j){
        Point p=points[res[j-1]]-points[res[j-2]];
        Point q=points[order[i]]-points[res[j-1]];
        return edges?cross(p,q)<0:cross(p,q)<eps;
    };
    for(int i=0; i<size; i++){
        while(num>1 and check(i,num))num--;
        res[num++]=order[i];
    }
    for(int i=size-2,t=num; i>=0; i--){
        while(num>t and check(i,num))num--;
        res[num++]=order[i];
    }
    res.resize(num-1);
    return res;
}

signed main(void){
    cin.tie(0); cout.tie(0);
    ios::sync_with_stdio(false);

    int n; cin>>n;
    vector<Point> a(n);
    rep(i,n)cin>>a[i].x>>a[i].y;

    vector<double> ans(n,0);
    vector<int> vec=ConvexHull(a,false);

    int t=vec.size();
    rep(i,t){
        double rad1=amp(rot90(a[vec[(i-1+t)%t]]-a[vec[i]]));
        double rad2=amp(rot90(a[vec[i]]-a[vec[(i+1)%t]]));
        double rad3=rad2-rad1;
        if(rad3<0)rad3+=pi*2;
        ans[vec[i]]=rad3/(pi*2);
    }

    cout<<fixed<<setprecision(20);
    rep(i,n)cout<<ans[i]<<endl;

}

Measured memory_bytes: 256