#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <utility>
#include <vector>
#define ll long long
#define itn int
#define endl '\n'
#define co(ans) cout<<ans<<endl
#define COYE cout<<"YES"<<endl
#define COYe cout<<"Yes"<<endl
#define COye cout<<"yes"<<endl
#define CONO cout<<"NO"<<endl
#define CONo cout<<"No"<<endl
#define COno cout<<"no"<<endl
#define FORE(i,a) for(auto &i:a)
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define FFOR(i,a,b) for(int i=(a);i<=(b);++i)
#define REP(i,n)  FOR(i,0,n)
#define RREP(i,n)  FFOR(i,1,n)
#define PB push_back
#define MP make_pair
#define ALL(V) (V).begin(),(V).end()
#define SORT(V) sort((V).begin(),(V).end())
#define REVERSE(V) reverse((V).begin(),(V).end())
#define EACH(V,i) for(typeof((V).begin()) i=(V).begin();i!=(V).end();++i)
#define equals(a,b) (fabs((a)-(b))<EPS)
#define INF ((1LL<<62)-(1LL<<31))
#define EPS 1e-10
#define PI 3.141592653589793238
#define MOD 1000000007
#define MAX 5100000
using namespace std;
using Graph=vector<vector<int>>;
inline int toInt(string s){int v;istringstream sin(s);sin>>v;return v;}
template<class T>inline string toString(T x){ostringstream sout;sout<<x;return sout.str();}
template<class T>bool chmax(T &a,const T &b){if(a<b){a=b;return 1;}return 0;}
template<class T>bool chmin(T &a,const T &b){if(b<a){a=b;return 1;}return 0;}
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
const int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0};
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
bool CAN[150];

////////// 凸包 //////////

class Point{
  public:
  double x,y;
  Point(double x=0,double y=0): x(x),y(y){}
  Point operator + (Point p){return Point(x+p.x,y+p.y);}
  Point operator - (Point p){return Point(x-p.x,y-p.y);}
  Point operator * (double a){return Point(a*x,a*y);}
  Point operator / (double a){return Point(x/a,y/a);}
  double abs(){return sqrt(norm());}
  double norm(){return x*x+y*y;}
  bool operator < (const Point &p)const{return x!=p.x ? x<p.x : y<p.y;}
  bool operator == (const Point &p)const{return fabs(x-p.x)<EPS && fabs(y-p.y)<EPS;}
};
typedef Point Vector;
typedef vector<Point> Polygon;
double dot(Vector a,Vector b){return a.x*b.x+a.y*b.y;}
double cross(Vector a,Vector b){return a.x*b.y-a.y*b.x;}
int ccw(Point p0,Point p1,Point p2){
  Vector a=p1-p0;
  Vector b=p2-p0;
  if(cross(a,b)>EPS) return 1;
  if(cross(a,b)<-EPS) return -1;
  if(dot(a,b)<-EPS) return 2;
  if(a.norm()<b.norm()) return -2;
  return 0;
}
Polygon andrewScan(Polygon s){
  Polygon u,l;
  if(s.size()<3) return s;
  sort(s.begin(),s.end());
  u.push_back(s[0]);
  u.push_back(s[1]);
  l.push_back(s[s.size()-1]);
  l.push_back(s[s.size()-2]);
  
  for(int i=2; i<s.size(); ++i){
    for(int j=u.size(); j>=2 && ccw(u[j-2],u[j-1],s[i])!=-1; --j){
      u.pop_back();
    }
    u.push_back(s[i]);
  }
  
  for(int i=s.size()-3; i>=0; --i){
    for(int j=l.size(); j>=2 && ccw(l[j-2],l[j-1],s[i])!=-1; --j){
      l.pop_back();
    }
    l.push_back(s[i]);
  }
  
  reverse(l.begin(),l.end());
  for(int i=u.size()-2; i>=1; --i) l.push_back(u[i]);
  
  return l;
}

//////////////////////////////////////////////////



int main(){
  int N,ans=0;
  cin>>N;
  int A[N];
  double B[N];
  Polygon S(N);
  REP(i,N){
    cin>>S[i].x>>S[i].y;
  }
  
  if(N==2){
    REP(i,2) co(0.5);
    return 0;
  }
  
  Polygon T=S;
  Polygon SS=andrewScan(S);
  
  REP(i,SS.size()){
    REP(j,S.size()){
      if(SS[i]==S[j]){
        CAN[j]=true;
        A[j]=i;
      }
    }
    
    double AX,AY,BX,BY,CX,CY;
    AX=SS[i].x,AY=SS[i].y;
    if(i==0) BX=SS[SS.size()-1].x,BY=SS[SS.size()-1].y;
    else BX=SS[i-1].x,BY=SS[i-1].y;
    if(i==SS.size()-1) CX=SS[0].x,CY=SS[0].y;
    else CX=SS[i+1].x,CY=SS[i+1].y;
    
    double a,b,c;
    a=(BX-CX)*(BX-CX)+(BY-CY)*(BY-CY);
    b=(CX-AX)*(CX-AX)+(CY-AY)*(CY-AY);
    c=(AX-BX)*(AX-BX)+(AY-BY)*(AY-BY);
    
    B[i]=(-a+b+c)/(2*sqrt(b*c));
  }
  
  REP(i,N){
    if(CAN[i]) co(0.5-acos(B[A[i]])/(2*PI));
    else co(0);
  }
  return 0;
}

Measured memory_bytes: 384