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

#include <iostream>

#include <cstring>

#include <cmath>

#include <algorithm>

#include <queue>

#include <map>

#include <stack>

#include <vector>

#define maxn 10010

#define maxe 100010

#define MAXN 10010

typedef long long ll;

using namespace std;

const double eps=1e-5;

const int inf=0x3f3f3f3f;

const double pi=2.0*asin(1.0);

typedef double T1;

const double EPS = 1e-8;

int n;

struct Point

{

    T1 x,y;

    int id;

    Point(){};

    Point(T1 a,T1 b)

    {

        x=a,y=b;

    }

    void input()

    {

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

    }

    Point operator +(Point a)

    {

        Point b(x+a.x,y+a.y);

        return b;

    }

    Point operator -(Point a)

    {

        Point b(x-a.x,y-a.y);

        return b;

    }

    T1 operator *(Point a)

    {

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

    }

    T1 operator ^(Point a)

    {

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

    }

   bool operator<(const Point &another) const;

};

int tot;//凸包含有的顶点个数

Point p[MAXN], s[MAXN];//下标都从0开始，p是原来的点集，s是凸包点集

int sgn(double x)

{

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

    if (x > 0)

        return 1;

    else

        return -1;

}

double det(const Point &a1, const Point &a2, const Point &b1, const Point &b2)//求向量a与b的叉积

{

    return ((a2.x - a1.x) * (b2.y - b1.y) - (a2.y - a1.y) * (b2.x - b1.x));

}



double dist(const Point &p1, const Point &p2)

{

    return sqrt((p2.x - p1.x) * (p2.x - p1.x) + (p2.y - p1.y) * (p2.y - p1.y));

}



bool Point::operator<(const Point &another) const

{

    if (sgn(det(p[0], *this, p[0], another)) == 0)

        return dist(p[0], *this) < dist(p[0], another);

    else

        return det(p[0], *this, p[0], another) > 0;

}



void Graham()

{

    double min_y = p[0].y, min_x = p[0].x;

    int index = 0;

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

        if (p[i].y < min_y || (sgn(p[i].y - min_y) == 0 && p[i].x < min_x)) {

            min_y = p[i].y;

            min_x = p[i].x;

            index = i;

        }

    }

    swap(p[0], p[index]);

    sort(p + 1, p + n);

    s[0] = p[0]; s[1] = p[1];

    tot = 2;

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

        while (tot >= 2 && sgn(det(s[tot - 1], p[i], s[tot - 1], s[tot - 2])) <0) tot--;

        s[tot++] = p[i];

    }

}

double ans[maxn];

int main()

{

    while(scanf("%d",&n)==1)

    {

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

        {

            p[i].input();

            p[i].id=i;

        }

        Graham();

        int siz=tot;

        for(int i=0;i<siz;i++)

        {



            //printf("%f %f\n",p[i].x,p[i].y);

            int l=(i-1+siz)%siz;

            int r=(i+1)%siz;

            double aa=(s[l]-s[i])*(s[r]-s[i])/(dist(s[i],s[l])*dist(s[i],s[r]));

            double theta=acos(aa);

            ans[s[i].id]=(pi-theta)/(2*pi);

        }

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

        {

            printf("%.7f\n",ans[i]);

        }

    }

    return 0;

}

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

#include<cmath>

#include<algorithm>

using namespace std;

const double pi=acos(-1);

int n,x[101],y[101];

double p[201];

int pp;

double Max(double a,double b){return a>b?a:b;}

int main(){

	scanf("%d",&n);

	for(int i=1;i<=n;i++) scanf("%d%d",&x[i],&y[i]);

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

		for(int j=1;j<=n;j++)if(i!=j) p[++pp]=atan2(y[j]-y[i],x[j]-x[i]);

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

		for(int j=1;j<=pp;j++) p[pp+j]=p[j]+pi+pi;

		double mx=0;

		for(int j=1;j<=pp;j++) mx=max(mx,pi-p[j+pp-1]+p[j]);

		printf("%.8lf\n",mx/pi/2);

		pp=0;

	}

}

// Fastest known solution for this problem: