#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef vector<int> VI;
 
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
#define _overload3(_1,_2,_3,name,...) name
#define _rep(i,n) repi(i,0,n)
#define repi(i,a,b) for(int i=int(a);i<int(b);++i)
#define rep(...) _overload3(__VA_ARGS__,repi,_rep,)(__VA_ARGS__)
#define all(x) (x).begin(),(x).end()

const int mod=1e9+7;
 
using DD = double;
const DD INF = 1LL<<60;      // to be set appropriately
const DD EPS = 1e-10;        // to be set appropriately
const DD PI = acos(-1.0);
DD torad(int deg) {return (DD)(deg) * PI / 180;}
DD todeg(DD ang) {return ang * 180 / PI;}

/* Point */
struct Point {
    DD x, y;
    Point(DD x = 0.0, DD y = 0.0) : x(x), y(y) {}
    friend ostream& operator << (ostream &s, const Point &p) {return s << '(' << p.x << ", " << p.y << ')';}
};
inline Point operator + (const Point &p, const Point &q) {return Point(p.x + q.x, p.y + q.y);}
inline Point operator - (const Point &p, const Point &q) {return Point(p.x - q.x, p.y - q.y);}
inline Point operator * (const Point &p, DD a) {return Point(p.x * a, p.y * a);}
inline Point operator * (DD a, const Point &p) {return Point(a * p.x, a * p.y);}
inline Point operator * (const Point &p, const Point &q) {return Point(p.x * q.x - p.y * q.y, p.x * q.y + p.y * q.x);}
inline Point operator / (const Point &p, DD a) {return Point(p.x / a, p.y / a);}
inline Point conj(const Point &p) {return Point(p.x, -p.y);}
inline Point rot(const Point &p, DD ang) {return Point(cos(ang) * p.x - sin(ang) * p.y, sin(ang) * p.x + cos(ang) * p.y);}
inline Point rot90(const Point &p) {return Point(-p.y, p.x);}
inline DD cross(const Point &p, const Point &q) {return p.x * q.y - p.y * q.x;}
inline DD dot(const Point &p, const Point &q) {return p.x * q.x + p.y * q.y;}
inline DD norm(const Point &p) {return dot(p, p);}
inline DD abs(const Point &p) {return sqrt(dot(p, p));}
inline DD amp(const Point &p) {DD res = atan2(p.y, p.x); if (res < 0) res += PI*2; return res;}
inline bool eq(const Point &p, const Point &q) {return abs(p - q) < EPS;}
inline bool operator < (const Point &p, const Point &q) {return (abs(p.x - q.x) > EPS ? p.x < q.x : p.y < q.y);}
inline bool operator > (const Point &p, const Point &q) {return (abs(p.x - q.x) > EPS ? p.x > q.x : p.y > q.y);}
inline Point operator / (const Point &p, const Point &q) {return p * conj(q) / norm(q);}
inline int ccw(const Point &p, const Point &q, const Point &r){
  Point A,B;
  A=q-p;B=r-p;
  if(cross(A,B)>0) return +1; //ccw
  if(cross(A,B)<0) return -1; //cw
  if(dot(A,B)<0) return +2; //c-a-b
  if(norm(A)<norm(B)) return -2; //a-b-c
  return 0;
}

/* Line */
struct Line : vector<Point> {
    Line(Point a = Point(0.0, 0.0), Point b = Point(0.0, 0.0)) {
        this->push_back(a);
        this->push_back(b);
    }
    friend ostream& operator << (ostream &s, const Line &l) {return s << '{' << l[0] << ", " << l[1] << '}';}
};

/* Circle */
struct Circle : Point {
    DD r;
    Circle(Point p = Point(0.0, 0.0), DD r = 0.0) : Point(p), r(r) {}
    friend ostream& operator << (ostream &s, const Circle &c) {return s << '(' << c.x << ", " << c.y << ", " << c.r << ')';}
};

DD get_vector_length( Point v ) {
	return pow( ( v.x * v.x ) + ( v.y * v.y ), 0.5 );
}

//２つのベクトルABのなす角度θを求める
DD AngleOf2Vector(Point A, Point B )
{
	//　※ベクトルの長さが0だと答えが出ませんので注意してください。

	//ベクトルAとBの長さを計算する
	DD length_A = get_vector_length(A);
	DD length_B = get_vector_length(B);

	//内積とベクトル長さを使ってcosθを求める
	DD cos_sita = dot(A,B) / ( length_A * length_B );

	//cosθからθを求める
	DD sita = acos( cos_sita );	

	//ラジアンでなく0～180の角度でほしい場合はコメント外す
	//sita = sita * 180.0 / PI;

	return sita;
}

vector<Point> convex_hull(vector<Point> ps){
  int n=ps.size(),k=0;
  sort(ps.begin(),ps.end());
  vector<Point> res(2*n);
  for(int i=0;i<n;res[k++]=ps[i++]){
    while(k>=2&&ccw(res[k-2],res[k-1],ps[i])<=0)--k;
  }
  for(int i=n-2,t=k+1;i>=0;res[k++]=ps[i--]){
    while(k>=t&&ccw(res[k-2],res[k-1],ps[i])<=0)--k;
  }
  res.resize(k-1);
  return res;
}

int main(){
  int n;cin>>n;
  vector<Point> xy;
  rep(i,n){
    DD x,y;cin>>x>>y;
    xy.push_back(Point(x,y));
  }
  map<Point,DD> M;
  auto ch=convex_hull(xy);
  int chsz=ch.size();
  if(chsz==2){
    M[ch[0]]=M[ch[1]]=0.5;
    rep(i,n)cout<<setprecision(10)<<M[xy[i]]<<endl;
    exit(0);
  }
  rep(i,chsz){
    int prev=(i-1+chsz)%chsz;
    int next=(i+1)%chsz;
    Point P=(ch[prev]-ch[i]);
    Point Q=(ch[next]-ch[i]);
    DD r=AngleOf2Vector(P,Q);
    M[ch[i]]=0.5-r/(2*PI);
  }
  rep(i,n)cout<<setprecision(10)<<M[xy[i]]<<endl;
  
}


Measured memory_bytes: 256