// Original C++ solution (slower):
#include<cstdio>

#include<cstring>

#include<algorithm>

#include<stack>

#include<cmath>

#define SF scanf

#define PF printf

#define MAXN 110

#define EPS 1e-7

using namespace std;

const double Pi=acos(-1);

struct node{

    double x,y;

    int id;

    node(){}

    node(double xx,double yy):x(xx),y(yy) {}

    node operator + (const node &a) const {

        return node(x+a.x,y+a.y);

    }

    node operator - (const node &a) const {

        return node(x-a.x,y-a.y);

    }

    node operator * (const double &t) const {

        return node(x*t,y*t);

    }

    double operator *(const node &a) const{

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

    }

    double operator ^(const node &a) const{

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

    }

    bool operator <(const node &a) const {

        return fabs(y-a.y)<EPS?x<a.x:y<a.y;

    }

}p[MAXN],l1[MAXN];

stack<node> s1,s;

double ans[MAXN];

int n,cnt1;

void solve(node a1[],int &cnt){

    s.push(p[1]);

    s1.push(p[1]);

    s1.push(p[2]);

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

        while(!s.empty()&&((p[i]-s.top())^(s1.top()-s.top()))<-EPS){

            s.pop();

            s1.pop();

        }

        s.push(s1.top());

        s1.push(p[i]);

    }

    while(!s1.empty()){

        a1[++cnt]=s1.top();

        s1.pop();

    }

    while(!s.empty())

        s.pop();

}

bool cmp(node a,node b){

    return b<a;

}

double len(node a){

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

}

pair<long long,long long> b[MAXN];

bool check(){

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

        b[i].first=(long long)(p[i].x);

        b[i].second=(long long)(p[i].y);

    }

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

        long long xx1=b[i].first-b[i-1].first;

        long long xx2=b[i+1].first-b[i].first;

        long long yy1=b[i].second-b[i-1].second;

        long long yy2=b[i+1].second-b[i].second;

        if(yy1*xx2!=yy2*xx1)

            return 0;

    }

    return 1;

}

int main(){

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

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

    SF("%d",&n);

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

        SF("%lf%lf",&p[i].x,&p[i].y);

        p[i].id=i;

    }

    sort(p+1,p+1+n);

    if(n==2){

        PF("0.50000\n");

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

            PF("0.00000\n");

        PF("0.50000\n");

        return 0;

    }

    solve(l1,cnt1);

    sort(p+1,p+1+n,cmp);

    cnt1--;

    solve(l1,cnt1);

    cnt1--;

    for(int i=1;i<=cnt1;i++){

        int las,nxt;

        if(i==1)

            las=cnt1;

        else

            las=i-1;

        if(i==cnt1)

            nxt=1;

        else

            nxt=i+1;

        double d=((l1[nxt]-l1[i])*(l1[las]-l1[i]))/(len(l1[nxt]-l1[i])*len(l1[las]-l1[i]));

        //PF("[%lf]",fabs((l1[nxt]-l1[i])*(l1[i]-l1[las])));

        d=acos(-d);

        ans[l1[i].id]=d/(2.0*Pi);

    }

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

        PF("%.20lf\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: