#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cstring>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <map>
#include <set>
#include <bitset>
#include <numeric>
#include <utility>
#include <iomanip>
#include <algorithm>
#include <functional>
using namespace std;

typedef long long ll;

/*
  let's try computer shogi!!
 */

const ll DIST_INF = 1145141919;

// Implementation of Andrew's monotone chain 2D convex hull algorithm.
// Asymptotic complexity: O(n log n).
// Practical performance: 0.5-1.0 seconds for n=1000000 on a 1GHz machine.
#include <algorithm>
#include <vector>
using namespace std;

typedef double coord_t;         // coordinate type
typedef double coord2_t;  // must be big enough to hold 2*max(|coordinate|)^2

struct Point {
  coord_t x, y;

  bool operator <(const Point &p) const {
    return x < p.x || (x == p.x && y < p.y);
  }
};

// 2D cross product of OA and OB vectors, i.e. z-component of their 3D cross product.
// Returns a positive value, if OAB makes a counter-clockwise turn,
// negative for clockwise turn, and zero if the points are collinear.
coord2_t cross(const Point &O, const Point &A, const Point &B)
{
  return (A.x - O.x) * (B.y - O.y) - (A.y - O.y) * (B.x - O.x);
}

// Returns a list of points on the convex hull in counter-clockwise order.
// Note: the last point in the returned list is the same as the first one.
vector<Point> convex_hull(vector<Point> P)
{
  int n = P.size(), k = 0;
  if (n == 1) 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 && cross(H[k-2], H[k-1], P[i]) <= 0) k--;
    H[k++] = P[i];
  }

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

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

int main(){
  int a;
  cin >> a;
  vector<Point> ps;
  ps.resize(a);
  
  for(int i=0;i<a;++i){
    cin >> ps[i].x >> ps[i].y;
  }
  if(a == 2){
    cout<<0.5<<endl<<0.5<<endl;
    return 0;
  }
  vector<Point> conv = convex_hull(ps);
  cerr<<"ful"<<conv.size()<<endl;
  const int as = conv.size();
  double anss[as];
  double pi = 3.1415926535;
  for(int i=0;i<conv.size();++i){
    cerr<<conv[i].x<<","<<conv[i].y<<endl;
  }

  if(conv.size()==2){
    anss[0] = anss[1] = 0.5;
  }else{
  for(int i=0;i<as;++i){
    int l = ( i == 0 ? as-1 : i-1);
    int r = ( i == as - 1 ? 0 : i + 1);
    double ang = acos(  ( (conv[i].x - conv[l].x ) * (conv[i].x - conv[r].x ) + (conv[i].y - conv[l].y ) * (conv[i].y - conv[r].y ) ) / sqrt((conv[i].x - conv[l].x )*(conv[i].x - conv[l].x ) + (conv[i].y - conv[l].y ) *(conv[i].y - conv[l].y ) ) / sqrt( (conv[i].x - conv[r].x )*(conv[i].x - conv[r].x ) + (conv[i].y - conv[r].y ) *(conv[i].y - conv[r].y ) ) );
    if(ang < 0) { ang = ang + pi;}
    cerr << (pi - ang) / (2.0 * pi)<<endl;
    anss[i] = (pi - ang) / (2.0 * pi);
  }
  }
  cerr<<"---"<<endl;
  // xohack
  for(int i=0;i<a;++i){
    bool nz = false;
    for(int j=0;j<as;++j){
      if( abs(ps[i].x - conv[j].x) < 0.00001 && abs(ps[i].y - conv[j].y )< 0.00001){
	cout<<anss[j]<<endl;nz = true;
	break;
      }
    }
    if(!nz){
      cout<<0.0<<endl;
    }
  }
  
  return 0;
}

Measured memory_bytes: 256