#include <iostream>
#include <math.h>
#include <iomanip>
#include <stdio.h>
#include <set>
#include <queue>
#include <vector>
#include <map>
#include <cmath>
#include <algorithm>
#include <memory.h>
#include <string>
#include <sstream>
#include <cstdlib>
#include <ctime>
#include <cassert>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
typedef pair<LL,LL> PLL;

#define MP make_pair
#define PB push_back
#define FF first
#define SS second

#define FORN(i, n) for (int i = 0; i <  (int)(n); i++)
#define FOR1(i, n) for (int i = 1; i <= (int)(n); i++)
#define FORD(i, n) for (int i = (int)(n) - 1; i >= 0; i--)

#define DEBUG(X) { cout << #X << " = " << (X) << endl; }
#define PR0(A,n) { cout << #A << " = "; FORN(_,n) cout << A[_] << ' '; cout << endl; }

// #define FL fflush(stdout)

#define MOD 1000000007
#define INF 2000000000
#define MAXN 100010

int GLL(LL& x) {
  return scanf("%lld", &x);
}

int GI(int& x) {
  return scanf("%d", &x);
}

void GI_fast(int& x) {
#if defined(_WIN32) || defined(_WIN64)
  char t = _getchar_nolock();
  while (t < '0' || '9' < t) {
    t = _getchar_nolock();
  }
  x = t - '0';
  t = _getchar_nolock();
  while ('0' <= t && t <= '9') {
    x *= 10; x += t - '0';
    t = _getchar_nolock();
  }
#else
  char t = getchar_unlocked();
  while (t < '0' || '9' < t) {
    t = getchar_unlocked();
  }
  x = t - '0';
  t = getchar_unlocked();
  while ('0' <= t && t <= '9') {
    x *= 10; x += t - '0';
    t = getchar_unlocked();
  }
#endif
}

void GS_fast(char* x) {
#if defined(_WIN32) || defined(_WIN64)
  char t = _getchar_nolock();
  while (t == ' ') {
    t = _getchar_nolock();
  }
  while (t != ' ') {
    *x = t;
    x++;
    t = _getchar_nolock();
  }
#else
  char t = getchar_unlocked();
  while (t == ' ') {
    t = getchar_unlocked();
  }
  while (t != ' ') {
    *x = t;
    x++;
    t = getchar_unlocked();
  }
#endif
}

void print_buf_fast(char* buf, int len) {
  FORN(i, len) {
#if defined(_WIN32) || defined(_WIN64)
    _putchar_nolock(buf[i]);
#else
    putchar_unlocked(buf[i]);
#endif
  }
}

void print_int_fast(int d) {
  int sz = 1;
  for (; sz <= d && sz < 1e9; sz*=10);
  sz /= 10;
  for (; sz > 0; sz /= 10) {
    char c = '0' + d/sz;
    d %= sz;
#if defined(_WIN32) || defined(_WIN64)
    _putchar_nolock(c);
#else
    putchar_unlocked(c);
#endif
  }
#if defined(_WIN32) || defined(_WIN64)
  _putchar_nolock('\n');
#else
  putchar_unlocked('\n');
#endif
}


LL N;
vector<LL> x;
vector<LL> y;

map<LL, set<LL>> idx;
set<LL> toErase;

struct Vector {
  LL x;
  LL y;
};

//void p() { printf("------------\n"); for (auto& kv : idx) { printf("%lld: ", kv.FF); for (auto v : kv.SS) { printf("%lld ", v); } printf("\n"); } printf("------------\n"); }

LL determinant(LL i, LL j, LL k) {
  // -           -
  // | x[i] - x[j], x[k] - x[j] |
  // | y[i] - y[j], y[k] - y[j] |
  // -           -
  LL det = (x[i] - x[j]) * (y[k] - y[j]) - (x[k]- x[j]) * (y[i] - y[j]);
  if (det > 0LL) return 1LL;
  if (det == 0LL) return 0LL;
  else return -1LL;
}

LL getMiddlePoint(LL i, LL j, LL k) {
  LL minX = min(x[i], min(x[j], x[k]));
  LL minY = min(y[i], min(y[j], y[k]));
  LL maxX = max(x[i], max(x[j], x[k]));
  LL maxY = max(y[i], max(y[j], y[k]));

//	printf("min: (%lld, %lld), max (%lld, %lld)\n", minX, minY, maxX, maxY);

  if (!((x[i] == minX || x[i] == maxX) && (y[i] == minY || y[i] == maxY))) {
//		printf("middle: (%lld, %lld)\n", x[i], y[i]);
    return i;
	} else if (!((x[j] == minX || x[j] == maxX) && (y[j] == minY || y[j] == maxY))) {
//		printf("middle: (%lld, %lld)\n", x[j], y[j]);
    return j;
	}
  else {
//		printf("middle: (%lld, %lld)\n", x[k], y[k]);
    return k;
	}
}

void convexHull() {
  // brute force convex hull
  FORN(i, N) {
    for (LL j = i+1; j < N; j++) {
      LL signs = 0;
      bool same = true;
      FORN(k, N) {
        if (k == i || k == j) continue;
        LL det = determinant(i, j, k);
        same &= (signs * det >= 0);
        signs = det;
      }
      if (same) {
          idx[i].insert(j);
      }
    }
  }

//  p();
  // fill in the line segments
  // at this point expect each point to be paired with two other points
  for (auto& kv : idx) {
    for (auto v : kv.SS) {
      idx[v].insert(kv.FF);
    }
  }

//  p();

  for (auto& kv : idx) {
    auto i = kv.FF;
    for (auto j : kv.SS) {
      for (auto k : kv.SS) {
        if (j == k) continue;
        LL det = determinant(i, j, k);
				auto m = getMiddlePoint(i, j, k);
//				printf("middle of (%lld, %lld), (%lld, %lld), (%lld, %lld) is (%lld, %lld)\n", x[i], y[i], x[j], y[j], x[k], y[k], x[m], y[m]);
        if (det == 0) toErase.insert(m);
      }
    }
  }
//  p();

  for (auto e : toErase) {
//		printf("erasing %lld\n", e);
    if (idx.find(e) != idx.end()) {
      idx.erase(e);
    }
    for (auto& kv : idx) {
      kv.SS.erase(e);
    }
  }
//  p();

  
}

double angle(Vector v1, Vector v2) {
  double dot = v1.x * v2.x + v1.y * v2.y;
  double len1 = sqrt(v1.x * v1.x + v1.y * v1.y);
  double len2 = sqrt(v2.x * v2.x + v2.y * v2.y);
  double param = dot / (len1 * len2);
//  printf("<%lld, %lld>, <%lld, %lld>\n", v1.x, v1.y, v2.x, v2.y); cout << "dot: " << dot << endl; cout << "len1: " << len1 << endl; cout << "len2: " << len2 << endl; cout << "param: " << param << endl; cout << acos(param) << endl;
  return acos(param);
}

int main() {
  srand(time(NULL));
  GLL(N);

  FORN(i, N) {
    LL t;
    GLL(t);
    x.PB(t);
    GLL(t);
    y.PB(t);
  }

  if (N == 2) {
    printf("0.5\n");
    printf("0.5\n");
    return 0;
  }

  convexHull();

  map<LL, double> solution;
  // get angles formed by vectors
  for (auto& kv : idx) {
    LL c = kv.FF;

    if (kv.SS.size() == 1) {
      solution[c] = 0.5;
      continue;
    }
    auto it = kv.SS.begin();
    LL l = *it;
    LL r = *(++it);
//    printf("c: %d, l: %d, r: %d\n", c, l, r);
    Vector v1;
    Vector v2;
    v1.x = x[l] - x[c];
    v1.y = y[l] - y[c];
    v2.x = x[r] - x[c];
    v2.y = y[r] - y[c];

    double a = angle(v1, v2);
    if (a > M_PI) a -= M_PI;
    a = M_PI - a;

    double total = 2 * M_PI;
    solution[c] = a/total;
  }

  FORN(i, N) {
    printf("%.20f\n", solution[i]);
  }


  return 0;
}


Measured memory_bytes: 768