#include <bits/stdc++.h>
using namespace std;
typedef long long int LL;

template <typename T>
ostream& operator <<(ostream& out, const vector<T>& vec) {
    out << "[";
    for (int x : vec) out << x << ", ";
    out << "]";
    return out;
}

#if DEBUG && !ONLINE_JUDGE
    ifstream input_from_file("input.txt");
    #define cin input_from_file
    #define dbg_var(x) clog << #x << ": " << x << endl;
#endif

struct Point{
    LL x, y;
    Point(LL x, LL y): x(x), y(y) {}
    Point(): x(0), y(0) {}
    
    Point operator - (const Point &other) const{ return Point(x-other.x, y-other.y);}
    LL operator ^ (const Point &other) const{
        return x * other.y - y * other.x;
    }
    
    LL Norm2(){return x*x + y*y;}
    
    bool operator < (const Point &other) const{
        if(x < other.x) return true;
        if(x > other.x) return false;
        return y < other.y;
    }
    bool operator == (const Point &other) const{ return (x == other.x) and (y == other.y);}
};

short int GetSign(LL val) {
    if (val == 0) return 0;
    return (val > 0) - (val < 0);
}

short int RelativePosition(const Point& O,const Point& A,const Point& B){
    return GetSign((A-O)^(B-O));
}

vector<int> ConvexHull(const vector<Point>& points){
    int N = points.size();
    vector <int> sorted_indexes(N);
    for (int i = 0; i < (int)sorted_indexes.size(); i++) sorted_indexes[i] = i;
    
    // Sorting from south to north (and from west to east) the points.
    sort(sorted_indexes.begin(), sorted_indexes.end(),
        [&points](int i, int j) {
            return points[i] < points[j];
        });

    // All points are equal.
    if (points[sorted_indexes[0]] == points[sorted_indexes.back()]) return {0};

    vector<int> anticlockwise, clockwise;
    anticlockwise.push_back(sorted_indexes[0]);
    clockwise.push_back(sorted_indexes[0]);

    for (int i = 1; i < N; i++) {
        // Finds the convex hull of the first i+1 points.
        int index = sorted_indexes[i];
        Point V = points[index];

        // Comparing V with the line generated by the last two points in
        // the anticlockwise array.
        while (anticlockwise.size() > 1 and
               RelativePosition(points[anticlockwise.rbegin()[1]], V,
                                points[anticlockwise.back()]) != -1) {
            anticlockwise.pop_back();
        }
        anticlockwise.push_back(index);
        
        // Comparing V with the line generated by the last two points in
        // the clockwise array.
        while (clockwise.size() > 1 and
               RelativePosition(points[clockwise.rbegin()[1]], V,
                                points[clockwise.back()]) != 1) {
            clockwise.pop_back();
        }
        clockwise.push_back(index);
    }

    // Joining anticlockwise and clockwise in a single vector.
    anticlockwise.pop_back();
    reverse(clockwise.begin(), clockwise.end());
    clockwise.pop_back();
    anticlockwise.insert(anticlockwise.end(), clockwise.begin(), clockwise.end());
    return anticlockwise;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    
    int n;
    cin >> n;
    
    vector<Point> P(n);
    vector<double> ans(n,0);
    
    for(int i=0; i<n; i++) cin >> P[i].x >> P[i].y;
    
    vector<int> CH = ConvexHull(P);
    int m = CH.size();
    
    for(int i=0; i<m; i++){
        int Ai = CH[i];
        int Bi = CH[(i+1)%m];
        int Ci = CH[(i+m-1)%m];
        //~ cerr << Ci << ' ' << Ai << ' ' << Bi << endl;
        
        Point A = P[Ai];
        Point B = P[Bi];
        Point C = P[Ci];
        
        ans[Ai] = (atan2(C.y-A.y, C.x-A.x) - atan2(B.y-A.y, B.x-A.x))/(8*atan(1));
        while(ans[Ai] < 0) ans[Ai] += 1;
        ans[Ai] = 0.5 - ans[Ai];
    }
    
    cout.precision(10);
    for(int i=0; i<n; i++) cout << fixed << ans[i] << '\n';
}


Measured memory_bytes: 256