#include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep2(i, m, n) for(int i=int(m); i<int(n); ++i)
#define drep2(i, m, n) for(int i=int(m-1); i>=int(n); --i)
#define rep(i, n) rep2(i, 0, n)
#define drep(i, n) drep2(i, n, 0)
#define all(a) a.begin(), a.end()
#define fst first
#define snd second
using ll = long long;
using ld = long double;
using V = vector<int>;
using Vll = vector<ll>;
using Vld = vector<ld>;
using VV = vector<V>;
using VVll = vector<Vll>;
using VVld = vector<Vld>;
using P = pair<int, int>;
using Pll = pair<ll, ll>;
using Pld = pair<ld, ld>;
template<typename T> inline bool chmin(T& a, T b) {if(a>b) {a=b; return true;} return false;}
template<typename T> inline bool chmax(T& a, T b) {if(a<b) {a=b; return true;} return false;}
inline int Log2(ll x) {int k; for(k=0; x>0; ++k) x>>=1; return k;} // number of binary digits
template<typename T> inline int count_between(vector<T>& a, T l, T r) {
  return lower_bound(all(a), r) - lower_bound(all(a), l); // [l, r)
}
template<typename T> istream& operator>>(istream& is, vector<T>& v) {
  rep(i, v.size()) is >> v[i]; return is;
}
template<typename T> ostream& operator<<(ostream& os, const vector<T>& v) {
  rep(i, v.size()) os << v[i] << endl; return os;
}
const int INF  = 1<<30;
const ll INFll = 1ll<<62;
const ld EPS   = 1e-10;
const int MOD  = int(1e9)+7;


struct Point {
  ld x, y;
  int id;
  Point(ld x=0, ld y=0, int id=-1): x(x), y(y), id(id) {}
  Point& operator+=(const Point& v) { x += v.x; y += v.y; return *this;}
  Point operator+(const Point& v) const { return Point(*this) += v;}
  Point& operator-=(const Point& v) { x -= v.x; y -= v.y; return *this;}
  Point operator-(const Point& v) const { return Point(*this) -= v;}
  Point& operator*=(ld s) { x *= s; y *= s; return *this;}
  Point operator*(ld s) const { return Point(*this) *= s;}
  Point& operator/=(ld s) { x /= s; y /= s; return *this;}
  Point operator/(ld s) const { return Point(*this) /= s;}
  ld dot(const Point& v) const { return x*v.x + y*v.y;}
  ld cross(const Point& v) const { return x*v.y - v.x*y;}
  ld norm2() const { return x*x + y*y;}
  ld norm() const { return sqrt(norm2());}
  Point rotate90() const { return Point(y, -x);}
  int ort() const { // orthant
    if (abs(x) < EPS && abs(y) < EPS) return 0;
    if (y > 0) return x>0 ? 1 : 2;
    else return x>0 ? 4 : 3;
  }
  // bool operator<(const Point& v) const { // argument
  //   int o = ort(), vo = v.ort();
  //   if (o != vo) return o < vo;
  //   return cross(v) > 0;
  // }
  bool operator<(const Point& v) const { // lexicographical
		return x < v.x || (x == v.x && y < v.y);
	}
};
istream& operator>>(istream& is, Point& v) {
  is >> v.x >> v.y; return is;
}
ostream& operator<<(ostream& os, const Point& v) {
  os << "(" << v.x << ", " << v.y << ")"; return os;
}


vector<Point> convex_hull(vector<Point> P) {
	int n = P.size(), k = 0;
	if (n <= 3) return P;
	vector<Point> H(2*n);

	// Sort points lexicographically
	sort(P.begin(), P.end());

	// Build lower hull
	for (int i = 0; i < n; ++i) {
		while (k >= 2 && (H[k-1] - H[k-2]).cross(P[i] - H[k-2]) <= 0) k--;
		H[k++] = P[i];
	}

	// Build upper hull
	for (int i = n-2, t = k+1; i >= 0; --i) {
		while (k >= t && (H[k-1] - H[k-2]).cross(P[i] - H[k-2]) <= 0) k--;
		H[k++] = P[i];
	}

	H.resize(k-1);
	return H;
}


int main() {
  ll n; cin >> n;
  vector<Point> P(n);
  rep(i, n) {
    cin >> P[i];
    P[i].id = i;
  }

  auto H = convex_hull(P);
  int k = H.size();

  Vld rad(k);
  rep(i, k) {
    int j = (i+1) % k;
    Point q = (H[i] - H[j]).rotate90();
    rad[i] = atan2(q.y, q.x);
  }

  Vld ans(n);
  rep(i, k) {
    int j = (i+1) % k;
    ld a = rad[j] - rad[i];
    if (a < 0) a += 2*M_PI;
    if (a > 2*M_PI) a -= 2*M_PI;
    ans[H[j].id] = a / (2 * M_PI);
  }

  cout << setprecision(12);
  cout << ans;
  return 0;
}


Measured memory_bytes: 512