#include <bits/stdc++.h>
 
using namespace std;
 
const int MOD=1e9+7;
const double PI=3.14159265359;

template<class T> class Point2D{
    public:
    T x,y;
    int pos;
    Point2D(){}
    Point2D(T _x, T _y, int _pos):x(_x), y(_y), pos(_pos){}
    void disp(){
        cout<<x<<" "<<y<<" "<<pos<<endl;
    }
    Point2D<T> operator +(Point2D<T> pt){
        return Point2D<T>(x+pt.x, y+pt.y, -1);
    }
    Point2D<T> operator -(Point2D<T> pt){
        return Point2D<T>(x-pt.x, y-pt.y, -1);
    }
};

template<class T> class ConvexHull{
    public:
    vector<Point2D<T>> points;
    ConvexHull(vector<Point2D<T>> pts):points(pts.begin(),pts.end()){}
    
    T crossProd(Point2D<T> v1, Point2D<T> v2){
        return v1.x*v2.y-v2.x*v1.y;
    }
    
    T dotProd(Point2D<T> v1, Point2D<T> v2){
        return v1.x*v2.x+v1.y*v2.y;
    }
    
    bool lt(Point2D<T> base, Point2D<T> p1, Point2D<T> p2){
        if(p1.pos==base.pos) return true;
        if(p2.pos==base.pos) return false;
        auto v1=p1-base, v2=p2-base;
        auto cp=crossProd(v1,v2);
        return (cp>0 ||(!cp && (dotProd(v1,v1)<dotProd(v2,v2))));
    }
    vector<Point2D<T>> grahamScan(bool removeColin=true){
        auto ps=*min_element(points.begin(), points.end(), 
        [](auto &p1, auto & p2){return p1.x<p2.x||(p1.x==p2.x && p1.y<p2.y);});
        sort(points.begin(),points.end(), [ps, this](auto p1, auto p2){return this->lt(ps,p1,p2);});
        vector<Point2D<T>> ans;
        ans.push_back(ps);
        int n=points.size();
        if(removeColin){
            for(int i=1; i<n; i++){
                while(ans.size()>=2 && crossProd(ans[ans.size()-1]-ans[ans.size()-2], points[i]-ans[ans.size()-1])<=0){
                    ans.pop_back();
                }
                ans.push_back(points[i]);
            }
        }
        else{
            for(int i=1; i<n; i++){
                while(ans.size()>=2 && crossProd(ans[ans.size()-1]-ans[ans.size()-2], points[i]-ans[ans.size()-1])<0){
                    ans.pop_back();
                }
                ans.push_back(points[i]);
            }
        }
        return ans;
    }
    
};
int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    int n;
    cin>>n;
    vector<Point2D<long long>> points(n);
    for(int i=0; i<n; i++){
        long long x,y;
        cin>>x>>y;
        points[i]=Point2D<long long>(x,y,i);
    }
    /*
    for(auto p:points){
        p.disp();
    }
    */
    vector<double> probs(n);
    
    ConvexHull<long long> ch(points);
    auto a=ch.grahamScan();
    /*
    for(auto p:a){
        p.disp();
    }
    */
    if(a.size()==2){
        for(auto p:a){
            probs[p.pos]=0.5;
        }
    }
    else{
        int sz=a.size();
        for(int i=0; i<sz; i++){
            int prev=(i-1+sz)%sz, next=(i+1)%sz;
            auto v1=a[prev]-a[i], v2=a[next]-a[i];
            double v1a=ch.dotProd(v1,v1), v2a=ch.dotProd(v2,v2);
            //cout<<v1a<<" "<<v2a<<endl;
            //cout<<ch.dotProd(v1,v2)<<endl;
            double angle=acos(ch.dotProd(v1,v2)/(sqrt(v1a)*sqrt(v2a)));
            probs[a[i].pos]=(PI-angle)/(2*PI);
            
        }
    }
    for(auto d:probs){
        cout<<setprecision(12)<<d<<endl;
    }
    
    return 0;
}

Measured memory_bytes: 256