#include <bits/stdc++.h>
#include <type_traits>
using namespace std;

using ll=int64_t;
#define int ll

#define FOR(i,a,b) for(int i=int(a);i<int(b);i++)
#define REP(i,b) FOR(i,0,b)
#define MP make_pair
#define PB push_back
#define EB emplace_back
#define ALL(x) x.begin(),x.end()
auto& errStream=cerr;
#ifdef LOCAL
#define cerr (cerr<<"-- line "<<__LINE__<<" -- ")
#else
class CerrDummy{}cerrDummy;
template<class T>
CerrDummy& operator<<(CerrDummy&cd,const T&){
	return cd;
}
using charTDummy=char;
using traitsDummy=char_traits<charTDummy>;
CerrDummy& operator<<(CerrDummy&cd,basic_ostream<charTDummy,traitsDummy>&(basic_ostream<charTDummy,traitsDummy>&)){
	return cd;
}
#define cerr cerrDummy
#endif
#define REACH cerr<<"reached"<<endl
#define DMP(x) cerr<<#x<<":"<<x<<endl
#define ZERO(x) memset(x,0,sizeof(x))
#define ONE(x) memset(x,-1,sizeof(x))

using pi=pair<int,int>;
using vi=vector<int>;
using ld=long double;

template<class T,class U>
ostream& operator<<(ostream& os,const pair<T,U>& p){
	os<<"("<<p.first<<","<<p.second<<")";
	return os;
}

template<class T>
ostream& operator <<(ostream& os,const vector<T>& v){
	os<<"{";
	REP(i,(int)v.size()){
		if(i)os<<",";
		os<<v[i];
	}
	os<<"}";
	return os;
}

ll read(){
	ll i;
	scanf("%"  SCNd64,&i);
	return i;
}

void printSpace(){
	printf(" ");
}

void printEoln(){
	printf("\n");
}

void print(ll x,int suc=1){
	printf("%" PRId64,x);
	if(suc==1)
		printEoln();
	if(suc==2)
		printSpace();
}

string readString(){
	static char buf[3341000];
	scanf("%s",buf);
	return string(buf);
}

char* readCharArray(){
	static char buf[3341000];
	static int bufUsed=0;
	char* ret=buf+bufUsed;
	scanf("%s",ret);
	bufUsed+=strlen(ret)+1;
	return ret;
}

template<class T,class U>
void chmax(T& a,U b){
	if(a<b)
		a=b;
}

template<class T,class U>
void chmin(T& a,U b){
	if(b<a)
		a=b;
}

template<class T>
T Sq(const T& t){
	return t*t;
}

#define CAPITAL
void Yes(bool ex=true){
	#ifdef CAPITAL
	cout<<"YES"<<endl;
	#else
	cout<<"Yes"<<endl;
	#endif
	if(ex)exit(0);
}
void No(bool ex=true){
	#ifdef CAPITAL
	cout<<"NO"<<endl;
	#else
	cout<<"No"<<endl;
	#endif
	if(ex)exit(0);
}

const ll infLL=LLONG_MAX/3;

#ifdef int
const int inf=infLL;
#else
const int inf=INT_MAX/2-100;
#endif

const double PI=acos(-1);
const double eps=1e-9;

template<class D>
struct Vec2{
	D x,y;
	Vec2(D xx=0,D yy=0):x(xx),y(yy){
	}
	bool operator<(const Vec2&rhs)const{
		return (x!=rhs.x)?(x<rhs.x):(y<rhs.y);
	}
	Vec2& operator +=(const Vec2&rhs){
		x+=rhs.x;
		y+=rhs.y;
		return *this;
	}
	Vec2 operator +(const Vec2&rhs)const{
		return Vec2(*this)+=rhs;
	}
	Vec2& operator -=(const Vec2&rhs){
		x-=rhs.x;
		y-=rhs.y;
		return *this;
	}
	Vec2 operator -(const Vec2&rhs)const{
		return Vec2(*this)-=rhs;
	}
	Vec2& operator *=(D d){
		x*=d;
		y*=d;
		return *this;
	}
	Vec2 operator *(D d)const{
		return Vec2(*this)*=d;
	}
	Vec2& operator /=(D d){
		x/=d;
		y/=d;
		return *this;
	}
	Vec2 operator /(D d)const{
		return Vec2(*this)/=d;
	}
	D norm()const{
		return Sq(x)+Sq(y);
	}
	double lengthImpl(true_type)const{
		return sqrt(norm());
	}
	D lengthImpl(false_type)const{
		return sqrt(norm());
	}
	auto length()const{
		return lengthImpl(is_same<D,int>());
	}
};
template<class D>
Vec2<D> operator*(D d,const Vec2<D>& v){
	return v*d;
}
template<class D>
ostream& operator<<(ostream&os,const Vec2<D>& p){
	return os<<"{"<<p.x<<","<<p.y<<"}";
}
template<class D>
D dot(Vec2<D> a,Vec2<D> b){
	return a.x*b.x+a.y*b.y;
}
template<class D>
D cross(Vec2<D> a,Vec2<D> b){
	return a.x*b.y-a.y*b.x;
}
template<class D>
int sgn(D x){
	if(x>0)return 1;
	else if(x<0)return -1;
	else return 0;
}
//ccw 1, line 0, cw -1
template<class D>
int ccw(Vec2<D> a,Vec2<D> b,Vec2<D> c){
	return sgn(cross(b-a,c-a));
}
template<class D>
complex<double> toC(Vec2<D> v){
	return complex<double>(v.x,v.y);
}
//a->b->c と動くときに、どれだけ曲がるか
//直進する時は 0
template<class D>
double turnArg(Vec2<D> a,Vec2<D> b,Vec2<D> c){
	auto p=toC(b-a);
	auto q=toC(c-b);
	return arg(q/p);
}

//assume a,b,c lie on the same line
//returns if the order is a-b-c
//not verified
template<class D>
bool between(Vec2<D> a,Vec2<D> b,Vec2<D> c,bool inc=true){
	return sgn(dot(a-b,c-b))<=(inc?0:-1);
}

template<class D>
bool parallelVV(Vec2<D> a,Vec2<D> b){
	return !sgn(cross(a,b));
}

using P=Vec2<int>;

//no point is in a edge
vector<P> CalcConvex(vector<P> ps){
	{
		auto itr=min_element(ALL(ps));
		swap(*ps.begin(),*itr);
	}
	vector<P> convex;
	sort(ps.begin()+1,ps.end(),[&](P a,P b){
		int s=sgn(ccw(ps[0],a,b));
		if(s) return s>0;
		else return between(ps[0],a,b,false);
	});
	REP(i,ps.size()){
		while(int(convex.size())>=2){
			P a=convex[int(convex.size())-2];
			P b=convex[int(convex.size())-1];
			P c=ps[i];
			if(sgn(ccw(a,b,c))>0)
				break;
			convex.pop_back();
		}
		convex.PB(ps[i]);
	}
	return convex;
}

signed main(){
	int n=read();
	vector<P> ps(n);
	map<P,int> idx;
	REP(i,n){
		ps[i].x=read();
		ps[i].y=read();
		idx[ps[i]]=i;
	}
	vector<P> c=CalcConvex(ps);
	vector<double> ans(n,0);
	int s=c.size();
	REP(i,s){
		P p=c[(i+s-1)%s];
		P q=c[i];
		P r=c[(i+1)%s];
		double theta=turnArg(p,q,r);
		if(theta<0)
			theta+=2*PI;
		ans[idx[q]]=theta/(2*PI);
	}
	cout<<fixed<<setprecision(20);
	for(auto v:ans)
		cout<<v<<endl;
}


Measured memory_bytes: 384