#ifndef DEBUG
#define NDEBUG
#endif

#include <algorithm>
#include <array>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <sstream>
#include <unordered_map>
#include <vector>


#define INF 2000000000
#define MOD 1000000007
#define ALL(x) std::begin(x), std::end(x)


struct point_t;


struct vector_t {
  double x;
  double y;

  vector_t(double xx = 0.0, double yy = 0.0) : x(xx), y(yy) {};

  vector_t(const point_t& p);

public:
  const double operator[](int i) const {
    return i == 0 ? x : y;
  };

  double& operator[](int i) {
    return i == 0 ? x : y;
  };

public:
  vector_t operator+(const vector_t& v) const {
    return vector_t(x + v.x, y + v.y);
  };

  vector_t& operator+=(const vector_t& v) {
    x += v.x;
    y += v.y;

    return *this;
  };

  vector_t operator-() const {
    return vector_t(- x, - y);
  };

  vector_t operator-(const vector_t& v) const {
    return vector_t(x - v.x, y - v.y);
  };

  vector_t& operator-=(const vector_t& v) {
    x -= v.x;
    y -= v.y;

    return *this;
  };

  vector_t operator*(double a) const {
    return vector_t(x * a, y * a);
  };

  vector_t operator/(double a) const {
    return vector_t(x / a, y / a);
  };

  vector_t& operator*=(double a) {
    x *= a;
    y *= a;

    return *this;
  };

  double operator*(const vector_t& v) const {
    return x * v.x + y * v.y;
  };

  double cross(const vector_t& v) const {
    return x * v.y - y * v.x;
  };

public:
  double length() const {
    return sqrt(x * x + y * y);
  };

  double length2() const {
    return x * x + y * y;
  };

public:
  void normalize() {
    double l = length();

    x /= l;
    y /= l;
  };

public:
  friend vector_t operator*(double a, const vector_t& v) {
    return vector_t(a * v.x, a * v.y);
  };
};

struct point_t {
  double x;
  double y;
  double w;

  point_t(double xx = 0.0, double yy = 0.0, double ww = 1.0) : x(xx), y(yy), w(ww) {};

  point_t(const point_t& p) : x(p.x), y(p.y), w(p.w) {};

  point_t(const vector_t& v) : x(v.x), y(v.y), w(1.0) {};

public:
  const double operator[](int i) const {
    return i == 0 ? x : i == 1 ? y : w;
  };

  double& operator[](int i) {
    return i == 0 ? x : i == 1 ? y : w;
  };

public:
  point_t operator+(const vector_t& v) const {
    return point_t(x + v.x, y + v.y);
  };

  point_t operator+(const point_t& p) const {
    return point_t(x + p.x, y + p.y);
  };

  point_t& operator+=(const point_t& p) {
    x = x + p.x;
    y = y + p.y;

    return *this;
  };

  point_t& operator+=(const vector_t& v) {
    x = x + v.x;
    y = y + v.y;

    return *this;
  };

  vector_t operator-(const point_t& p) const {
    return vector_t(x / w - p.x / p.w,
                    y / w - p.y / p.w);
  };

  point_t& operator-=(const vector_t& v) {
    x = x - v.x;
    y = y - v.y;

    w = 1.0;

    return *this;
  };

  point_t operator*(double a) const {
    return point_t(x * a, y * a, w);
  };

  point_t& operator*=(double a) {
    x *= a;
    y *= a;

    return *this;
  };

  point_t operator/(double a) const {
    return point_t(x / a, y / a, w);
  };

  point_t& operator/=(double a) {
    x /= a;
    y /= a;

    return *this;
  };

public:
  void cartesianize() {
    x /= w;
    y /= w;
    w  = 1.0;
  };
  
  point_t cartesianized() {
    return point_t(x / w, y / w);
  };

  void honogenize() {
    x *= w;
    y *= w;
  };
  
  point_t honogenized() {
    return point_t(x * w, y * w, w);
  };
  
public:
  bool operator==(const point_t& ob) const {
    return x == ob.x && y == ob.y && w == ob.w;
  };

  bool point_is_equivalent(const point_t& ob, double t = 1.0e-9) const {
    double dx = x - ob.x;
    double dy = y - ob.y;

    return dx * dx + dy * dy < t * t;
  };

public:
  friend point_t operator+(const vector_t& v, const point_t& p) {
    return point_t(p.x / p.w + v.x,
                   p.y / p.w + v.y);
  };
};


vector_t::vector_t(const point_t& p)
{
  assert(fabs(p.w) > 1.0e-9);
  
  x = p.x / p.w;
  y = p.y / p.w;
};


class matrix_t
{
public:
  matrix_t() {
    identitize();
  };
  
public:
  const double* operator[](int i) const {
    return matrix_[i];
  };

  double* operator[](int i) {
    return matrix_[i];
  };

public:
  void identitize() {
    memset(matrix_, 0, sizeof(matrix_));

    matrix_[0][0] =
      matrix_[1][1] =
      matrix_[2][2] = 1.0;
  };

  void transpose() {
    for (int i = 0; i < 3; i ++)
      for (int j = i + 1; j < 3; j ++)
        if (i != j)
          std::swap(matrix_[i][j], matrix_[j][i]);
  };

public:
  matrix_t operator*(const matrix_t& m) const {
    matrix_t r;

    for (int i = 0; i < 3; i ++)
      for (int j = 0; j < 3; j ++)
        r[i][j] =
          matrix_[i][0] * m[0][j] +
          matrix_[i][1] * m[1][j] +
          matrix_[i][2] * m[2][j];

    return r;
  };

  vector_t operator*(const vector_t& v) const {
    vector_t r;

    for (int i = 0; i < 3; i ++)
      r[i] =
        matrix_[i][0] * v.x +
        matrix_[i][1] * v.y +
        matrix_[i][2];
    
    return r;
  };

  point_t operator*(const point_t& p) const {
    point_t r;

    for (int i = 0; i < 3; i ++)
      r[i] =
        matrix_[i][0] * p.x +
        matrix_[i][1] * p.y +
        matrix_[i][2] * p.w;
    
    return r;
  };

public:
  static matrix_t translation(double x = 0, double y = 0) {
    matrix_t m;

    m[0][2] = x;
    m[1][2] = y;

    return m;
  };

  static matrix_t rotation(double theta) {
    double c = cos(theta), s = sin(theta);
    
    matrix_t m;

    m[0][0] =    m[1][1] = c;
    m[0][1] = - (m[1][0] = s);

    return m;
  };

  static matrix_t scale(double s = 1) {
    matrix_t m;

    m[0][0] = m[1][1] = s;

    return m;
  };

private:
  double matrix_[3][3];
};


class quickhull_t {
public:
  quickhull_t(const std::vector<point_t>& pts) : pts_(pts), N_(pts_.size()) {};

public:
  std::vector<int> compute() const {
    std::vector<int> a(N_);

    std::iota(std::begin(a), std::end(a), 0);
    
    return compute(std::move(a));
  };

  std::vector<int> compute(std::vector<int> a) const {
    std::pair<double, int> xm, xp, ym, yp;

    xp.first = -(xm.first = INF_);
    yp.first = -(ym.first = INF_);

    for (int i = 0, size = a.size(); i < size; i ++) {
      const point_t& p = pts_[a[i]];
      
      if (p.x < xm.first)
        xm = std::make_pair(p.x, i);
      
      if (p.x > xp.first)
        xp = std::make_pair(p.x, i);
      
      if (p.y < ym.first)
        ym = std::make_pair(p.y, i);

      if (p.y > yp.first)
        yp = std::make_pair(p.y, i);
    }

    std::vector<int>::iterator s, e;
    
    if (xp.first - xm.first > yp.first - ym.first) {
      s = std::begin(a) + xm.second;
      e = std::begin(a) + xp.second;
    }
    else {
      s = std::begin(a) + ym.second;
      e = std::begin(a) + yp.second;
    }

    const point_t p(pts_[*s]);

    const vector_t v(pts_[*e] - p);

    if (e == std::begin(a)) {
      if (s == std::end(a) - 1) {
        std::swap(*s, *e);
      }
      else {
        std::swap(*e, a.back ());
        std::swap(*s, a.front());
      }
    }
    else {
      std::swap(*s, a.front());
      std::swap(*e, a.back ());
    }

    s = std::begin(a);
    e = std::end  (a) - 1;

    auto i = std::begin(a) + 1;

    while (i < e)
      if (v.cross(pts_[*i] - p) > 1.0e-9) {
        std::swap(*i, *(-- e));
      }
      else {
        i ++;
      }

    std::swap(*i, a.back());

    //   a: s                   i                 e
    //      8 1 2 13 15 12 10 0 4 7 11 6 5 14 3 9 .
    //      | ~~~~~~~~~~~~~~~~~ | ~~~~~~~~~~~~~~~
    //      |         |         |             `-- Indices that corresponding points reside
    //      |         |         |                 in the left side of line
    //      |         |         `-- End point index
    //      |         `-- Indices that corresponding points reside
    //      |             in the right side of line
    //      `-- Start point index

    auto e1 = dfs(pts_[*i], pts_[*s], std::begin(a) + 1, i);
    auto e2 = dfs(pts_[*s], pts_[*i], i + 1, std::end(a));

    a.erase(std::copy(i, e2, e1), std::end(a));

    return std::move(a);
  };

private:
  std::vector<int>::iterator dfs(const point_t& p,
                                 const point_t& q,
                                 std::vector<int>::iterator s,
                                 std::vector<int>::iterator e) const {

    if (e - s <= 1)
      return e;

    const vector_t v1(q - p), perp(-v1.y, v1.x);

    double d2p = -1.0e+9, d2;

    std::vector<int>::iterator ip;

    for (auto i = s; i != e; ++ i) {
      if ((d2 = fabs(v1.cross(pts_[*i] - p))) > d2p) {
        d2p = d2;
        ip  = i;
      }
    }

    const point_t& r = pts_[*ip];

    // Note that it is guaranteed that all points including r reside
    // on the left side of vector pq:
    //
    //            r
    //          +             +
    //         /   `
    //    v3  /       `   v2
    //       /   +       `
    //      /               `
    //   p +________----------+ q
    //               v1

    const vector_t v2(r - q), v3(p - r);

    std::swap(*s, *ip);
    
    auto i = s + 1;

    for ( ; i != e; ) {
      const point_t& pt = pts_[*i];

      // Points that are exactly on the line will survive.
      if (v2.cross(pt - q) > 1.0e-9 &&
          v3.cross(pt - r) > 1.0e-9) {
        
        std::swap(*i, *(-- e));
      }
      else {
        ++ i;
      }
    }

    assert(r == pts_[*s]);

    i = s + 1;

    for (auto j = e; i != j; )
      if (perp.cross(pts_[*i] - r) > 1.0e-9) {
        std::swap(*i, *(-- j));
      }
      else {
        ++ i;
      }
    
    //   a: s                   i               e
    //      4 1 2 13 15 12 10 0 7 11 6 5 14 3 9 .
    //      | ~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~
    //      |         |         `-- Indices that corresponding points reside
    //      |         |             in the right side of line
    //      |         `-- Indices that corresponding points reside
    //      |             in the left side of line
    //      `-- Pivotal index
    
    std::swap(*s, *(i - 1));

    //   a: s                   i               e
    //      0 1 2 13 15 12 10 4 7 11 6 5 14 3 9 .
    //      ~~~~~~~~~~~~~~~~~ | ~~~~~~~~~~~~~~~
    //              |         |   `-- Indices that corresponding points reside
    //              |         |       in the right side of line
    //              |         `-- Pivotal index
    //              `-- Indices that corresponding points reside
    //                  in the left side of line

    assert(r == pts_[*(i - 1)]);

    auto e1 = dfs(r, q, s, i - 1);
    auto e2 = dfs(p, r, i, e);

    return std::copy(i - 1, e2, e1);
  };
    
private:
  const std::vector<point_t>& pts_;

  const int N_;

private:
  static const int INF_;
};

const int quickhull_t::INF_ = 1000000000;


int main(int argc, char** argv)
{
  std::cin.tie(0);
  std::ios_base::sync_with_stdio(0);

  std::cout << std::fixed << std::setprecision(20);
  std::cerr << std::fixed << std::setprecision(3);

  int N;

  std::cin >> N;

  std::vector<point_t> pts(N);

  for (int i = 0; i < N; i ++)
    std::cin >> pts[i].x >> pts[i].y;

  std::vector<int> x(N);

  std::iota(ALL(x), 0);

  std::vector<int> hull(quickhull_t(pts).compute(x));

  int size = hull.size();

  std::vector<vector_t> perps;

  for (int i = 0; i < size; i ++) {
    int j = (i + 1) % size;

    vector_t e(pts[hull[j]] - pts[hull[i]]), perp(e.y, - e.x);

    perps.push_back(perp);
  }

  double c[111] = {0};

  for (int i = 0; i < size; i ++) {
    int j = (i - 1 + size) % size;

    double t = acos(perps[i] * perps[j] / (perps[i].length() * perps[j].length()));

    c[hull[i]] = t / M_PI / 2;
  }

  for (int i = 0; i < N; i ++)
    std::cout << c[i] << std::endl;

  return 0;
}


Measured memory_bytes: 256