#include <bits/stdc++.h>
#define FOR(v, a, b) for(int v = (a); v < (b); ++v)
#define FORE(v, a, b) for(int v = (a); v <= (b); ++v)
#define REP(v, n) FOR(v, 0, n)
#define REPE(v, n) FORE(v, 0, n)
#define REV(v, a, b) for(int v = (a); v >= (b); --v)
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define ITR(it, c) for(auto it = (c).begin(); it != (c).end(); ++it)
#define RITR(it, c) for(auto it = (c).rbegin(); it != (c).rend(); ++it)
#define EXIST(c,x) ((c).find(x) != (c).end())
#define LLI long long int
#define fst first
#define snd second
#define popcount __builtin_popcount

#ifdef DEBUG
#include <misc/C++/Debug.cpp>
#else
#define dump(x) ((void)0)
#endif

#define gcd __gcd

using namespace std;
template <class T> constexpr T lcm(T m, T n){return m/gcd(m,n)*n;}

template <typename I> void join(ostream &ost, I s, I t, string d=" "){for(auto i=s; i!=t; ++i){if(i!=s)ost<<d; ost<<*i;}ost<<endl;}
template <typename T> istream& operator>>(istream &is, vector<T> &v){for(auto &a : v) is >> a; return is;}
template <typename T, typename U> istream& operator>>(istream &is, pair<T,U> &p){is >> p.first >> p.second; return is;}

template <typename T, typename U> bool chmin(T &a, const U &b){return (a>b ? a=b, true : false);}
template <typename T, typename U> bool chmax(T &a, const U &b){return (a<b ? a=b, true : false);}
template <typename T, size_t N, typename U> void fill_array(T (&a)[N], const U &v){fill((U*)a, (U*)(a+N), v);}

class pt{
public:
  double x, y;
  pt(): x(0), y(0){}
  pt(double x, double y): x(x), y(y){}
};

pt operator+(const pt &a, const pt &b){return pt(a.x+b.x, a.y+b.y);}
pt operator-(const pt &a, const pt &b){return pt(a.x-b.x, a.y-b.y);}
pt operator-(const pt &a){return pt(-a.x, -a.y);}
bool operator==(const pt &a, const pt &b){return a.x==b.x and a.y==b.y;}
bool operator!=(const pt &a, const pt &b){return !(a==b);}

bool operator<(const pt &a, const pt &b){return a.x<b.x or (a.x==b.x and a.y<b.y);}

double dot(const pt &a, const pt &b){return a.x*b.x+a.y*b.y;}
double cross(const pt &a, const pt &b){return a.x*b.y-a.y*b.x;}

double angle(const pt &a, const pt &b){ // 点aから点bへの角度
  return atan2(b.y-a.y, b.x-a.x);
}

ostream& operator<<(ostream &os, const pt &a){os << "(" << a.x << "," << a.y << ")"; return os;}

vector<pt> upper_hull(vector<pt> pts, bool upper=true){
  sort(ALL(pts), [](const pt &a, const pt &b){return (a.x < b.x) or (a.x == b.x and a.y < b.y);});
  if(upper) reverse(ALL(pts));
  
  vector<pt> ret;

  ret.push_back(pts.back());
  pts.pop_back();
  
  while(not pts.empty()){
    auto s = pts.back();
    pts.pop_back();

    if(ret.size() == 1){
      ret.push_back(s);
    }else{
      auto p = *(ret.end()-2);
      auto q = ret.back();

      if(cross(q-p, s-p) <= 0){
	ret.push_back(s);
      }else{
	ret.pop_back();
	pts.push_back(s);
      }
    }
  }

  return ret;
}

vector<pt> convex_hull(const vector<pt> &pts){
  vector<pt> ret = upper_hull(pts);
  auto lower = upper_hull(pts, false);

  ret.pop_back();
  lower.pop_back();

  for(auto &p : lower) ret.push_back(p);

  return ret;
}

int main(){
  cin.tie(0);
  ios::sync_with_stdio(false);

  int N;
  while(cin >> N){
    vector<double> ans(N);
    vector<pt> pts(N);
    map<pt,int> m;
    REP(i,N){
      double x, y; cin >> x >> y;
      pts[i] = pt(x,y);
      m[pts[i]] = i;
    }

    if(N==2){
      ans[0] = ans[1] = 0.5;
    }else{
      auto ch = convex_hull(pts);
      dump(ch);
      int k = (int)ch.size();
      REP(i,k){
	auto &p0 = ch[i];
	auto &p1 = ch[(i-1+k)%k];
	auto &p2 = ch[(i+1)%k];

	double a = fabs(angle(p0,p2) - angle(p0,p1));
	if(a>M_PI) a = 2*M_PI-a;

	a = (M_PI-a)/(2*M_PI);
	ans[m[p0]] = a;
      }
    }

    join(cout, ALL(ans), "\n");
  }
  
  return 0;
}


Measured memory_bytes: 384