#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <sstream>
#include <set>
#include <map>
#include <vector>
#include <list>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <string>
#include <queue>
#include <bitset>     //UWAGA - w czasie kompilacji musi byc znany rozmiar wektora - nie mozna go zmienic
#include <cassert>
#include <iomanip>        //do setprecision
#include <ctime>
#include <complex>
using namespace std;

#define FOR(i,b,e) for(int i=(b);i<(e);++i)
#define FORQ(i,b,e) for(int i=(b);i<=(e);++i)
#define FORD(i,b,e) for(int i=(b)-1;i>=(e);--i)
#define REP(x, n) for(int x = 0; x < (n); ++x)

#define ST first
#define ND second
#define PB push_back
#define MP make_pair
#define LL long long
#define ULL unsigned LL
#define LD long double

const double pi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;
const int mod=1000000007;
const double EPS=0.000000000000001;

typedef double coord_t;         // coordinate type
typedef double coord2_t;  // must be big enough to hold 2*max(|coordinate|)^2

struct Point {
	coord_t x, y;
	int idx;
	bool operator <(const Point &p) const {
		return x < p.x || (abs(x-p.x)<EPS && y < p.y);
	}
};

// 2D cross product of OA and OB vectors, i.e. z-component of their 3D cross product.
// Returns a positive value, if OAB makes a counter-clockwise turn,
// negative for clockwise turn, and zero if the points are collinear.
coord2_t cross(const Point &O, const Point &A, const Point &B)
{
	return (A.x - O.x) * (B.y - O.y) - (A.y - O.y) * (B.x - O.x);
}

// Returns a list of points on the convex hull in counter-clockwise order.
// Note: the last point in the returned list is the same as the first one.
vector<Point> convex_hull(vector<Point> P)
{
	int n = P.size(), k = 0;
	if (n == 1) return P;
	vector<Point> H(2*n);

	// Sort points lexicographically
	sort(P.begin(), P.end());

	// Build lower hull
	for (int i = 0; i < n; ++i) {
		while (k >= 2 && cross(H[k-2], H[k-1], P[i]) <= 0) k--;
		H[k++] = P[i];
	}

	// Build upper hull
	for (int i = n-2, t = k+1; i >= 0; i--) {
		while (k >= t && cross(H[k-2], H[k-1], P[i]) <= 0) k--;
		H[k++] = P[i];
	}

	H.resize(k-1);
	return H;
}


int main(){
	int n;
	double x[111]={},y[111]={};
	double xt[111]={},yt[111]={};
	LD deg[111]={},ans[111]={};
	cin>>n;
	if(n==2){
		cout<<0.5<<endl;
		cout<<0.5<<endl;
		return 0;
	}
	vector<Point> P(n);
	int min_y=mod,ind_miny=0;
	FOR(i,0,n){
		cin>>x[i]>>y[i];
		if(y[i]<min_y){
			min_y=y[i];
			ind_miny=i;
		}
		Point p1;
		p1.x=x[i];
		p1.y=y[i];
		p1.idx=i;
		P[i]=p1;
	}
	vector<Point> H=convex_hull(P);
	H.push_back(H[0]);
	H.push_back(H[1]);
	//FOR(i,1,H.size())cout<<H[i].x<<" "<<H[i].y<<endl;
	/*
	FOR(i,0,H.size()-2){
		cout<<"Point:"<<H[i].idx<<" =("<<H[i].x<<","<<H[i].y<<")"<<endl;
	}//*/
	LD sumdeg=0;
	FOR(i,1,H.size()-1){
		Point p1=H[i-1];
		Point p2=H[i];
		Point p3=H[i+1];
		Point a,b;
		a.x=p2.x-p1.x;
		a.y=p2.y-p1.y;
		b.x=p3.x-p2.x;
		b.y=p3.y-p2.y;
		LD coscos=(a.x*b.x+a.y*b.y);
		coscos/=sqrt(a.x*a.x+a.y*a.y)*sqrt(b.x*b.x+b.y*b.y);
		if(coscos<-1)coscos=-1;
		if(coscos>1)coscos=1;
		deg[H[i].idx]=acos((coscos));
		//cout<<"Point:"<<H[i].idx<<" deg:"<<deg[H[i].idx]/pi*180<<endl;
		sumdeg+=deg[H[i].idx];
	}
	//cout<<"sumdeg:"<<sumdeg<<endl;
	LD sumans=0;
	FOR(i,0,n){
		ans[i]=deg[i]/sumdeg;
		sumans+=ans[i];
	}
	FOR(i,0,n){
		printf("%.12Lf\n",ans[i]);
	}


    return 0;
}


Measured memory_bytes: 256