#include <cstdio>
#include <cstdint>
#include <cmath>
#include <vector>
#include <algorithm>
#include <complex>
#include <iostream>
#include <utility>
#include <tuple>

/* Note: adding declarations to `std` (below) causes undefined behavior
namespace std {
  template <class Tp>
  bool operator <(const std::complex<Tp>& a, const std::complex<Tp>& b) {
    return (real(a) != real(b))? real(a) < real(b) : imag(a) < imag(b);
  }
}
*/

template <class Tp>
struct point: public std::complex<Tp> {
  constexpr point(Tp re=Tp(), Tp im=Tp()): std::complex<Tp>(re, im) {}
  constexpr point(const std::complex<Tp>& z): std::complex<Tp>(z) {}
  bool operator <(const std::complex<Tp>& z) const {
    if (this->real() != z.real()) return this->real() < z.real();
    return this->imag() < z.imag();
  }
  std::pair<Tp, Tp> unpack() const {
    return {this->real(), this->imag()};
  }
};
template <class Tp>
using line = std::pair<point<Tp>, point<Tp>>;

template <class Tp>
static constexpr Tp pi = acos(Tp(0))*Tp(2);

static constexpr double eps = 1e-6;

template <class Tp>
Tp cross(const point<Tp>& a, const point<Tp>& b) {
  return std::imag(std::conj(a)*b);
}
template <class Tp>
Tp dot(const point<Tp>& a, const point<Tp>& b) {
  return std::real(std::conj(a)*b);
}
template <class Tp>
int ccw(point<Tp> a, point<Tp> b, point<Tp> c) {
  b -= a;
  c -= a;
  if (cross(b, c) > 0)             return +1;  // counter-clockwise
  if (cross(b, c) < 0)             return -1;  // clockwise
  if (dot(b, c) < 0)               return +2;  // c--a--b on line
  if (std::norm(b) < std::norm(c)) return -2;  // a--b--c on line
  return 0;
}

template <class Tp>
std::vector<size_t> convex_hull(const std::vector<point<Tp>>& ps) {
  size_t n = ps.size();
  size_t k = 0;
  std::vector<std::pair<point<Tp>, size_t>> psi;
  for (size_t i=0; i<n; ++i) psi.emplace_back(ps[i], i);
  std::sort(psi.begin(), psi.end());

  std::vector<size_t> ch(2*n);
  auto ccw_ = [&](size_t k, size_t i) {
    return ccw(psi[ch[k-2]].first, psi[ch[k-1]].first, psi[i].first);
  };
  for (size_t i=0; i<n; (ch[k++]=i++))
    while (k >= 2 && ccw_(k, i) <= 0) --k;
  for (size_t i=n-1, t=k+1; i--; (ch[k++]=i))
    while (k >= t && ccw_(k, i) <= 0) --k;

  std::vector<size_t> res(k-1);
  for (size_t i=0; i<k-1; ++i) res[i] = psi[ch[i]].second;
  return res;
}

template <class Tp>
std::pair<point<Tp>, Tp> midperpendicular(point<Tp> a, point<Tp> b) {
  point<Tp> mid = 0.5*(a+b);
  b -= a;
  point<Tp> perpendicular = (b/std::abs(b)) * std::polar(1.0, 0.5*pi<Tp>);
  return {mid, std::arg(perpendicular)};
}

int main() {
  using point = point<double>;

  size_t N;
  scanf("%zu", &N);

  if (N == 2) {
    puts("0.5");
    puts("0.5");
    return 0;
  }

  std::vector<point> z;
  for (size_t i=0; i<N; ++i) {
    double x, y;
    scanf("%lf %lf", &x, &y);
    z.emplace_back(x, y);
  }

  std::vector<size_t> ch = convex_hull(z);
  size_t M = ch.size();

  std::vector<double> res(N);

  for (size_t i=0; i<M; ++i) {
    size_t ip = (i+M-1) % M;
    size_t in = (i+1) % M;

    auto d0 = midperpendicular(z[ch[i]], z[ch[ip]]).second;
    auto d1 = midperpendicular(z[ch[in]], z[ch[i]]).second;

    res[ch[i]] = (d1-d0) / (2.0*pi<double>);
    if (res[ch[i]] < -eps) res[ch[i]] += 1;
  }

  for (size_t i=0; i<N; ++i)
    printf("%.12f\n", res[i]);
}


Measured memory_bytes: 256