// Original C++ solution (slower):
#include <stdio.h>

#include <cstring>

#include <iostream>

#include <cmath>

#include <algorithm>

#include <vector>

using namespace std;

const double pi = acos(-1);

double eps = 1e-8;

int cmp(double x){

    if(fabs(x)<eps)return 0;

    if(x>0)return 1;

    return -1;

}

struct point{

    double x,y;

    int id;

    point(){}

    point(double a,double b):x(a),y(b){}

    void input(){

        scanf("%lf%lf",&x,&y);

    }

    friend point operator - (const point &a, const point &b){

        return point(a.x-b.x,a.y-b.y);

    }

    friend bool operator == (const point &a,const point &b){

        return cmp(a.x-b.x)==0 && cmp(a.y-b.y)==0;

    }

    double norm(){

        return sqrt(x*x + y*y);

    }

};

double det(const point &a,const point &b){

    return a.x*b.y-a.y*b.x;

}

double dot(const point &a,const point &b){

    return a.x*b.x+a.y*b.y;

}

struct polygon_convex{

    vector<point> P;

    polygon_convex(int Size=0){

        P.resize(Size);

    }

};

bool comp_less(const point &a,const point &b){

    return cmp(a.x-b.x)<0 || cmp(a.x-b.x)==0 && cmp(a.y-b.y)<0;

}

polygon_convex convex_hull(vector<point> a){

    polygon_convex res(2*a.size()+5);

    sort(a.begin(),a.end(),comp_less);

    a.erase(unique(a.begin(),a.end()),a.end());

    int m = 0;

    for(int i=0;i<a.size();++i){

        while(m>1 && cmp(det(res.P[m-1]-res.P[m-2],a[i]-res.P[m-2]))<=0)--m;

        res.P[m++] = a[i];

    }

    int k = m;

    for(int i=int(a.size())-2;i>=0;i--){

        while(m>k && cmp(det(res.P[m-1]-res.P[m-2],a[i]-res.P[m-2]))<=0)--m;

        res.P[m++] = a[i];

    }

    res.P.resize(m);

    if(a.size()>1) res.P.resize(m-1);

    return res;

}

double ans[110];

int main(){

    int n;

    scanf("%d",&n);

    vector<point> a;

    for(int i=0;i<n;i++){

        point p;

        p.id = i;

        p.input();

        a.push_back(p);

    }

    if(n==2){

        printf("%lf\n%lf\n",0.5,0.5);

        return 0;

    }

    polygon_convex ret = convex_hull(a);

    for(int i=0;i<n;i++){

        ans[i] = 0;

    }

    int m = ret.P.size();

    if(ret.P.size()==2){

        ans[ret.P[0].id] = 0.5;

        ans[ret.P[1].id] = 0.5;

    }

    else{

        for(int i=0;i<ret.P.size();i++){

            point a1 = ret.P[(i+1)%m]-ret.P[i];

            point a2 = ret.P[(i-1+m)%m]-ret.P[i];

            double tem = dot(a1,a2);

            tem = tem/a1.norm()/a2.norm();

            tem = acos(tem);

            tem = (pi - tem)/2.0/pi;

            ans[ret.P[i].id] = tem;

        }

    }

    for(int i=0;i<n;i++){

        printf("%.6lf\n",ans[i]);

    }

}

// Optimized solution to the same problem (faster):
#include <cstdio>

#include <cstring>

#include <algorithm>

#include <cmath>

#define ld long double

#define MN 205

#define eps 1e-9

using namespace std;

const ld pi=acos(-1);

struct vec

{

	ld x,y; int pos;

	friend vec operator-(const vec& a,const vec& b) {return (vec){a.x-b.x,a.y-b.y};}

	friend ld operator/(const vec& a,const vec& b) {return a.x*b.y-a.y*b.x;}

	friend ld operator*(const vec& a,const vec& b) {return a.x*b.x+a.y*b.y;}

	friend ld abs(const vec& a) {return sqrt(a.x*a.x+a.y*a.y);}

}a[MN];

ld ans[MN];

int q[MN];

int n,tp;



inline int read()

{

	int n=0,f=1; char c=getchar();

	while (c<'0' || c>'9') {if(c=='-')f=-1; c=getchar();}

	while (c>='0' && c<='9') {n=n*10+c-'0'; c=getchar();}

	return n*f;

}



bool cmp1(const vec& a,const vec& b) {return a.x<b.x || a.x==b.x && a.y<b.y;}

bool cmp2(const vec& A,const vec& B)

{

	ld lt=(A-a[1])/(B-a[1]);

	if (fabs(lt)>eps) return lt>0;

	else return abs(A-a[1])<abs(B-a[1]);

}



int main()

{

//	freopen("data.in","r",stdin);

//	freopen("data.out","w",stdout);

	register int i;

	n=read();

//	printf("%d\n",n);	

	for (i=1;i<=n;++i)

		a[i].x=read(),a[i].y=read(),a[i].pos=i;

	if (n==1) return 0*printf("1");

	else if (n==2) return 0*printf("0.5000000\n0.5000000");

	sort(a+1,a+n+1,cmp1);

	sort(a+2,a+n+1,cmp2);

	q[tp=1]=1;

	for (i=2;i<=n;++i)

	{

		while (tp>1&&(a[q[tp]]-a[q[tp-1]])/(a[i]-a[q[tp-1]])<eps) --tp;

		q[++tp]=i;

	}

	q[tp+1]=q[1]; q[0]=q[tp];

//	for (i=1;i<=tp;++i) printf("%lld,%lld\n",a[q[i]].x,a[q[i]].y);	

//	for (i=1;i<=tp;++i) printf("%d ",a[q[i]].pos); puts("");

//	printf("%d\n",tp);

//	printf("%d %d\n",n,tp);

	for (i=1;i<=tp;++i)

	

	{

	

		ans[a[q[i]].pos]=

		(pi-acos((double)(

		((a[q[i-1]]-a[q[i]])*

		(a[q[i+1]]-a[q[i]]))

		/(abs(a[q[i-1]]-a[q[i]])*

		  abs(a[q[i+1]]-a[q[i]])))))/(pi*2);

//	printf("%.5lf\n",acos(

//		((a[q[i-1]]-a[q[i]])*

//		(a[q[i+1]]-a[q[i]]))

//		/(abs(a[q[i-1]]-a[q[i]])*

//		  abs(a[q[i+1]]-a[q[i]]))));

	}

	

	for (i=1;i<=n;++i) printf("%.10lf\n",(double)ans[i]);

}

// Fastest known solution for this problem: