#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
using ld = long double;
template<typename T> using V = vector<T>;
template<typename T> using VV = vector<vector<T>>;
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define eb emplace_back
#define all(v) (v).begin(),(v).end()
#define siz(v) (ll)(v).size()
#define rep(i,a,n) for(ll i=a;i<(ll)(n);++i)
#define repr(i,a,n) for(ll i=n-1;(ll)a<=i;--i)
#define lb lower_bound
#define ub upper_bound
#define ENDL '\n'
typedef pair<int,int> Pi;
typedef pair<ll,ll> PL;
const ll mod = 1000000007;
const ll INF = 1000000099;
const ll LINF = (ll)(1e18 +99);
const vector<ll> dx={-1,1,0,0},dy={0,0,-1,1};
template<typename T,typename U> inline bool chmin(T& t, const U& u){if(t>u){t=u;return 1;}return 0;}
template<typename T,typename U> inline bool chmax(T& t, const U& u){if(t<u){t=u;return 1;}return 0;}
template<typename T> inline T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<typename T,typename Y> inline T mpow(T a, Y n) {
  T res = 1;
  for(;n;n>>=1) {
    if (n & 1) res = res * a;
    a = a * a;
  }
  return res;
}

#define EPS 1e-7

int eql(db a){return fabs(a)<EPS;}
int eql(db a,db b){return eql(a-b);}

struct P{
  db x,y;
  P(db _x=db(),db _y=db()):x(_x),y(_y){}
  //デフォルトはdoubleのデフォルト引数

  P operator+(const P& r)const{return {x+r.x,y+r.y};}
  P operator-(const P& r)const{return {x-r.x,y-r.y};}
  P operator*(const double a)const{return {x*a,y*a};}
  P operator/(const double a)const{return {x/a,y/a};}

  P& operator+=(const P& r) {return *this = *this+r;}
  P& operator-=(const P& r) {return *this = *this-r;}
  P& operator*=(const db& r) {return *this = *this*r;}
  P& operator/=(const db& r) {return *this = *this/r;}

  bool operator==(const P& r)const{return eql(x-r.x) && eql(y-r.y);}
  bool operator<(const P& r)const{
    if(eql(x,r.x))return y<r.y;
    else return x<r.x;
  }

  db norm(){
    return x*x+y*y;
  }//大きさの二乗

  db abs(){
    return sqrt(norm());
  }//大きさ

};//Point

struct L{
  P a,b;
  L(db _ax,db _ay,db _bx,db _by):L(P(_ax,_ay),P(_bx,_by)){}
  L(P _a,P _b):a(_a),b(_b){}
};

db dot(P a,P b){
  return a.x*b.x + a.y*b.y;
}//dot product 内積

db crs(P a,P b){
  return a.x*b.y-a.y*b.x;
}//cross product 外積

int ccw(P a,P b){
  if(crs(a,b)>EPS)return -1;
  if(crs(a,b)<-EPS)return 1;
  if(dot(a,b)<-EPS)return 2;
  if(a.norm()<b.norm())return -2;
  return 0;
}
//counter clockwise
//-2,-1,0,1,2 : online_front,cw,on,counter_cw,online_back
int ccw(P a,P b,P c){
  return ccw(b-a,c-a);
}

bool intersect(P p1,P p2,P p3,P p4){
  return ccw(p1,p2,p3)*ccw(p1,p2,p4)<=0 && ccw(p3,p4,p1)*ccw(p3,p4,p2)<=0;
}
bool intersect(L a,L b){
  return intersect(a.a,a.b,b.a,b.b);
}//線分交差判定

//Convex Hull------------------------------------------------------------
vector<P> ConvexLower(const vector<P>& ps){
  int tp;
  vector<P> ans(0);
  for(P now:ps){
    tp=ans.size();
    --tp;
    while(0<tp){
      //if(ccw(ans[tp-1],ans[tp],now)==1)break;//線上を入れない
      if(ccw(ans[tp-1],ans[tp],now)!=-1)break;//線上を入れる
      ans.pop_back();
      --tp;
    }
    ans.push_back(now);
  }
  return ans;
}

vector<P> ConvexHull(vector<P> ps){
  vector<P> lower,upper;
  sort(ps.begin(),ps.end());
  ps.erase(unique(ps.begin(),ps.end()),ps.end());
  if(ps.size()<2)return ps;

  lower=ConvexLower(ps);
  reverse(ps.begin(),ps.end());
  upper=ConvexLower(ps);
  
  lower.insert(lower.end(),upper.begin()+1,upper.end()-1);
  return lower;
}

signed main(){
  cin.tie(0);ios::sync_with_stdio(false);
  cout<<fixed<<setprecision(20);
  ll n;cin>>n;
  V<db> ans(n,0);
  map<P,int> ind;
  V<P> v(n),p;
  rep(i,0,n){
    cin>>v[i].x>>v[i].y;
    ind[v[i]]=i;
  }
  p=ConvexHull(v);
  reverse(all(p));
cerr<<siz(p)<<ENDL;

  V<db> slp(siz(p));
  rep(i,0,siz(p)){
    slp[i]=atan2((-p[(i+1)%siz(p)].x+p[i].x),(p[(i+1)%siz(p)].y-p[i].y));
  }

  rep(i,0,siz(slp)){
    db ang=slp[(i+1)%siz(slp)]-slp[i];
    if(ang<0)ang+=2*M_PI;
    ans[ind[p[(i+1)%siz(slp)]]]=ang/(2*M_PI);
  }

  rep(i,0,n){
    cout<<ans[i]<<ENDL;
  }
}
//( ・ __ ・ ) KEEP BEING ORGANIZED
//CHECK overflow,vector_size,what to output?



Measured memory_bytes: 768