// see https://github.com/LumaKernel/vimfiles/tree/master/snippets/cp-cpp/temp.snip
/// --- .lumrc Template {{{ ///
#if 0
#define assert(...)
#endif
#include <bits/stdc++.h>
using namespace std;

using ll = long long;
using ull = unsigned long long;
using ld = long double;
using P = tuple<ll, ll>;
using P3 = tuple<ll, ll, ll>;
using VI = vector<int>;
using VL = vector<ll>;
using VVI = vector<VI>;
using VVL = vector<VL>;
using VP = vector<P>;
using VS = vector<string>;

#define omajinai ios::sync_with_stdio(false);cin.tie(0)

#define FOR(i,a,b) for(int i=int(a);i<int(b);++i)
#define FORI(i,a,b) for(int i=int(a);i<=int(b);++i)
#define REP(i,n) FOR(i,0,n)
#define REPI(i,n) FORI(i,0,n)
#define RFOR(i,a,b) for(int i=int(b)-1;i>=int(a);--i)
#define RFORI(i,a,b) for(int i=int(b);i>=int(a);--i)
#define RREP(i,n) RFOR(i,0,n)
#define RREPI(i,n) RFORI(i,0,n)

#define ALL(a) (a).begin(),(a).end()
#define UNIQUE(a) (a).erase(unique(ALL(a)),(a).end())
#define PB push_back
#define EACH(i,c) REP(i,(c).size())
#define REACH(i,c) RREP(i,(c).size())
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort(ALL(c))

#define BR cout<<"\n";

#ifdef DEBUG
#define dump(...) cerr<<"["<<__LINE__<< "] "<<#__VA_ARGS__<<" = "<<make_tuple(__VA_ARGS__)<<"\n";
#else
#define dump(...)
#endif

#define YES(x) cout<<((x)?"YES":"NO")<<"\n";
#define Yes(x) cout<<((x)?"Yes":"No")<<"\n";
#define yes(x) cout<<((x)?"yes":"no")<<"\n";

inline int omajinai_int_in(){omajinai;int n;cin>>n;return n;}
inline ll omajinai_ll_in(){omajinai;ll n;cin>>n;return n;}
inline string omajinai_string_in(){omajinai;string n;cin>>n;return n;}
inline int int_in(){int n;cin>>n;return n;}
inline ll ll_in(){ll n;cin>>n;return n;}
inline string string_in(){string n;cin>>n;return n;}
#define oini omajinai_int_in()
#define oinl omajinai_ll_in()
#define oins omajinai_string_in()
#define ini int_in()
#define inl ll_in()
#define ins string_in()

#define isInside(y,x) (0<=(y)&&(y)<h&&0<=(x)&&(x)<w)

#define fi(x) (get<0>(x))
#define se(x) (get<1>(x))
#define th(x) (get<2>(x))
#define fo(x) (get<3>(x))
#define fif(x) (get<4>(x))

template <typename T> ostream &operator<<(ostream &o, const vector<T> &v) { o << '{'; EACH(i, v) o << v[i] << (i != (int)v.size()-1 ? ", " : ""); o << "}";  return o; }

template<int n, class...T> typename enable_if<(n>=sizeof...(T))>::type _ot(ostream &, tuple<T...> const &){}
template<int n, class...T> typename enable_if<(n< sizeof...(T))>::type _ot(ostream & os, tuple<T...> const & t){ os << (n==0?"":", ") << get<n>(t); _ot<n+1>(os, t); }
template<class...T> ostream & operator<<(ostream & os, tuple<T...> const & t){ _ot<0>(os, t); return os; }

template <typename T> inline void smax(T &a, T b) { a = a > b ? a : b; }
template <typename T> inline void smin(T &a, T b) { a = a < b ? a : b; }

template<typename T> int log2max(T x) {
  int res = 0;
  ll tmp = 1;
  while(tmp < x) tmp <<= 1, res++;
  return res;
}

constexpr double PI = acos(-1);

/// }}}--- ///

constexpr int INF = 1e9+1;
constexpr ll LINF = 1e18+1;
constexpr int MOD = 1e9+7;

// EPS
constexpr double EPS = 1e-9;
/// --- Geometory Library {{{ ///
using Point = complex<double>;
#define X real()
#define Y imag()
#define dot(a, b) real(conj(a)*b)
#define cross(a, b) imag(conj(a)*b)
#define norm abs

// +1 : ccw
// -1 : cw
// +2 : a--b--c
// -2 : b--c--a
//  0 : b--a--c
int ccw(Point a, Point b, Point c) {
  b -= a; c -= a;
  if(cross(b, c) > EPS) return +1;
  if(cross(b, c) < -EPS) return -1;
  if(dot(b, c) < 0) return 0;
  if(norm(b) < norm(c)) return +2;
  return -2;
}

double arg(Point a, Point b) {
  return acos(dot(a, b) / norm(a) / norm(b));
}
/// ---}}} ///

struct GrahamScan {
  vector<Point> points;
  VI ids;
  VI hull;

  void add(Point p) {
    points.PB(p);
  }

  int operator[](int i) {
    return hull[i];
  }

  void scan() {
    int n = points.size();
    ids.resize(n);

    iota(ALL(ids), 0);
    sort(ALL(ids), [&](int a, int b) {
        return make_pair(points[a].X, points[a].Y) <
        make_pair(points[b].X, points[b].Y);
        });

    sort(begin(ids) + 1, end(ids), [&](int a, int b) {
        Point p1 = points[a] - points[ids[0]];
        Point p2 = points[b] - points[ids[0]];
        // p1.y / p1.x < p2.y / p2.x
        double ev = p1.Y * p2.X - p2.Y * p1.X;
        return abs(ev) < EPS ? norm(p1) < norm(p2) : ev < 0;
        });

    hull.PB(ids[0]);
    dump(ids);
    FORI(i, 1, n) {
      int ii = i%n;
      int st;
      while(hull.size() >= 2 &&
          (st = ccw(
                    points[hull[hull.size()-2]],
                    points[hull[hull.size()-1]],
                    points[ids[ii]]
                   ), st == -1)) hull.pop_back();
      dump(i, hull);
      hull.PB(ids[ii]);
      dump( hull);
    }

    hull.pop_back();
  }
};

double ans[100];
int main() {
  int n=ini;
  GrahamScan ecasdqina;
  REP(i, n) {
    int x=ini, y=ini;
    ecasdqina.add(Point(x, y));
  }
  ecasdqina.scan();
  VI &hull = ecasdqina.hull;
  vector<Point> &points = ecasdqina.points;
  int m = hull.size();
  dump(hull);
  EACH(i, hull) {
    ans[hull[i]] = arg(
        - (points[hull[(i+m-1)%m]] - points[hull[i]]),
        points[hull[(i+1)%m]] - points[hull[i]]
        ) / 2.0 / PI;
  }

  cout << setprecision(5);
  REP(i, n) cout << ans[i] << endl;
}


Measured memory_bytes: 256