#include<bits/stdc++.h>
#define pb           push_back
#define pii          pair<int,int>
#define vi           vector<int>
#define vpii         vector<pair<int,int>>
#define gph          map<int, vector<int>>
#define mp           make_pair
#define FOR(i, n) for (int i = 0; i <  (int)(n); i++)
#define FOR1(i, n) for (int i = 1; i <= (int)(n); i++)
#define FORD0(i, n) for (int i = (int)n; i >= 0; i--)
#define FORD1(i, n) for (int i = (int)n; i >= 1; i--)
#define FORS(i, n) for(; i < (int)(n); i++)
#define debug(X) { cout << #X << " = " << (X) << endl; }
#define printArr(A,n) { cout << #A << " = "; FOR(i,n) cout << A[i] << ' '; cout << endl; }
using namespace std;
#define int long long int
using namespace std; 
#define double long double
  
struct Point 
{ 
    int x, y; 
    int index;
    Point(int a, int b, int c = 0){
        x = a;
        y = b;
        index =c;
    }
    Point operator - (const Point& other){
        return Point(x - other.x, y - other.y);
    }
    double operator * (const Point& other){
        return x*other.x + y*other.y;
    }
}; 
  
int orientation(Point p, Point q, Point r) 
{ 
    int val = (q.y - p.y) * (r.x - q.x) - 
              (q.x - p.x) * (r.y - q.y); 
  
    if (val == 0) return 0;  // colinear 
    return (val > 0)? 1: 2; // clock or counterclock wise 
} 
  
vector<Point> chull(vector<Point>& points, int n) 
{ 
    vector<Point> hull; 
    if (n < 3) return hull; 
  
  
    int l = 0; 
    for (int i = 1; i < n; i++) 
        if (points[i].x < points[l].x) 
            l = i; 
    int p = l, q; 
    do
    { 
        hull.push_back(points[p]); 
        q = (p+1)%n; 
        for (int i = 0; i < n; i++) 
        { 
           if (orientation(points[p], points[i], points[q]) == 2) 
               q = i; 
        } 
        p = q; 
  
    } while (p != l);  // While we don't come to first point 
  
    return hull;
} 
/*
double mag(Point a){
    return sqrt(a.x*a.x + a.y*a.y);
}
double angle(Point a, Point b, Point c){
   (b -a)*(c- b); 


}*/

signed main(){
    ios_base::sync_with_stdio(false);cin.tie(NULL);
    
    int n;cin >> n;
    vector<double> ans(n);
    int x, y;
    vector<Point> pts;
    FOR(i, n){
        cin >> x >> y;
        Point p(x, y, i);
        pts.pb(p);
    }
    bitset<(int)1e3> rem;
    FOR(i ,n){
        for(int j = i+1; j < n; j++){
            for(int k = j + 1; k < n; k++){
                if(orientation(pts[i], pts[j], pts[k]) == 0){
                    if(pts[i].x <= max(pts[j].x, pts[k].x) && pts[i].x >= min(pts[j].x, pts[k].x) &&
                      pts[i].y <= max(pts[j].y, pts[k].y) && pts[i].y >= min(pts[j].y, pts[k].y)){
                        rem[i] =1;
                    }else if(pts[j].x <= max(pts[i].x, pts[k].x) && pts[j].x >= min(pts[i].x, pts[k].x) &&
                      pts[j].y <= max(pts[i].y, pts[k].y) && pts[j].y >= min(pts[i].y, pts[k].y)){
                        rem[j] = 1;
                    }else rem[k] =1;
                }
            }
        }
    }
    vector<Point> pts2;
    FOR(i, n){
        if(!rem[i])pts2.pb(pts[i]);
    }
   // debug(pts2.size());
    pts = pts2;
    vector<Point> hull = chull(pts2, pts2.size());
    //clockwise order
    reverse(hull.begin(), hull.end());
  //  debug(hull.size());
    for(Point p: hull){
 //       cout << p.x << " " << p.y  << endl;
    }

    //const double pi = 3.14159265358979;
    const double pi = 3.141592653589793238462643383279;
    if(pts.size() <= 2){
        for(auto x: pts){
            ans[x.index] = 0.5;
        }
    }else{
        for(int i = 0;  i < hull.size(); i++){
            int prev = (i-1 + hull.size()) % hull.size();
            int nex = (i+1 + hull.size()) % hull.size();
            double y = hull[nex].x - hull[i].x; 
            double x = hull[nex].y - hull[i].y;
            double m = -y/x;

            y = hull[prev].x - hull[i].x; 
            x = hull[prev].y - hull[i].y;
            double m2 = -y/x;
            double diff = atan(m2) - atan(m);
            diff= abs(diff);
            ans[hull[i].index] = diff/(2*pi);
          //  debug((pi - diff)/(2 * pi));
            Point in = hull[i] - hull[prev];
            Point out = hull[nex] - hull[i];
//            debug(diff/(2*pi));
            //debug((atan2(in.x*out.y - in.y*out.x, in*out)*360)/(2*pi));
            ans[hull[i].index] = (-atan2(in.x*out.y - in.y*out.x, in*out))/(2*pi);
        }
    }
    FOR(i, n){
        printf("%.20Lf\n", ans[i]);
    }
}




Measured memory_bytes: 256