#include <iostream>
#include <cstdio>
#include <complex>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cmath>
#include <iomanip>
using namespace std;

using Point = complex<double>;
using Line  = pair< Point, Point >;
#define X real()
#define Y imag()

const double EPS = 1e-6;

// 2つのベクトルの内積を求める
double dot(Point a, Point b) {
    return (a.X * b.X + a.Y * b.Y);
}

// 2つのベクトルの外積を求める
double cross(Point a, Point b) {
    return (a.X * b.Y - a.Y * b.X);
}

// ccw (c が直線(線分) ab に対してどのような位置関係か？)
// Verified: AOJ CGL_1_C: Counter-Clockwise
// +1 ... a → b で半時計方向に折れて b → c (COUNTER_CLOCKWISE)
// -1 ... a → b で時計方向に折れて b → c (CLOCKWISE)
// +2 ... c, a, b がこの順で同一直線状にある場合 (ONLINE_BACK)
// -2 ... a, b, c がこの順で同一直線状にある場合 ( or a == b ) (ONLINE_FRONT)
//  0 ... c が線分 ab 上にある場合 (点 a, b 上を含む) (ON_SEGMENT)
int ccw(Point a, Point b, Point c) {
    b -= a; c -= a;
    if( cross(b,c) > EPS ) return +1;
    if( cross(b,c) < -EPS ) return -1;
    if( dot(b,c) < 0 ) return +2;
    if( norm(b) < norm(c) ) return -2;
    return 0;
}

// (基本) 頂点の順序 (sortやmax_elementに必要)
namespace std {
    bool operator<(const Point a, const Point b) {
        return a.X != b.X ? a.X < b.X : a.Y < b.Y;
    }
}

vector<Point> convexHull(vector<Point> ps) {
    int n = ps.size();
    // sort(ps.begin(),ps.end(), cmp_y);
    sort(ps.begin(),ps.end());
    int k = 0;
    vector<Point> convex(n*2);
    for(int i=0; i<n; i++) {
        while (k >= 2 && ccw(convex[k-2], convex[k-1], ps[i]) != 1 ) k--;
        convex[ k++ ] = ps[i];
    }
    for(int i=n-2, t=k; i>=0; i--) {
        while (k > t && ccw(convex[k-2], convex[k-1], ps[i]) != 1 ) k--;
        convex[ k++ ] = ps[i];
    }
    convex.resize(k-1);
    return convex;
}

// p1 と p2 に対する垂直二等分線
Line get_line(Point p1, Point p2) {
    // 中点
    Point center = (p1 + p2) / 2.0;
    // 法線ベクトル
    Point vec = (p1 - p2) * Point(0, 1);
    return make_pair(center, center + vec);
}

const double PI = acos(-1);

double get_line_angle(Line l) {
    Point p = l.second - l.first;
    return atan2(p.Y, p.X);
}

double get_angle(Line l1, Line l2, Point p) {
    double deg1 = get_line_angle(l1);
    double deg2 = get_line_angle(l2);

    double ans;
    if(ccw(l1.first, l1.second, p) != ccw(l2.first, l2.second, p)) {
        ans = deg1 - deg2;
    }
    else {
        ans = deg2 - deg1;
    }
    // (0, PI]
    while(ans >  PI) ans -= PI;
    while(ans <=  0) ans += PI;
    return ans;
}

int main() {
    int N; cin >> N;
    vector<Point> pts(N);
    for(int i=0; i<N; i++) {
        double x, y; cin >> x >> y;
        pts[i] = Point(x, y);
    }

    cout << fixed << setprecision(12);
    vector<Point> convex = convexHull(pts);
    for(int i=0; i<N; i++) {
        int idx;
        // fprintf(stderr, "convex size = %zu\n", convex.size());
        for(idx = 0; idx < convex.size(); idx++) {
            if(pts[i] == convex[idx]) break;
        }

        if(idx == convex.size()) {
            cout << 0.0 << endl;
        }
        else {
            int sz = convex.size();
            Point pre = convex[(idx-1+sz)%sz], nxt = convex[(idx+1+sz)%sz];

            Line l1 = get_line(convex[idx], pre);
            Line l2 = get_line(convex[idx], nxt);

            double ans = get_angle(l1, l2, convex[idx]);
            // fprintf(stderr, "ans = %.12f\n", ans);
            cout << ans / 2 / PI << endl;
        }
    }
    return 0;
}

Measured memory_bytes: 384