//
//  main.cpp
//

#include <algorithm>
#include <array>
#include <assert.h>
#include <complex>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <math.h>
#include <memory>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>

using namespace std;

using ll = int64_t;
using ull = uint64_t;
constexpr ll LL_MAX = numeric_limits<ll>::max();
constexpr ull ULL_MAX = numeric_limits<ull>::max();

template<typename T>
vector<T> make_vec_nd(T init, ll size) {
	return vector<T>(size, init);
}
template<typename T, typename... Args>
auto make_vec_nd(T init, ll size, Args... rest) {
	auto inner = make_vec_nd(init, rest...);
	return vector<decltype(inner)>(size, inner);
}

#define rep(i, a, b) for (ll i = (a); i < (b); i++)
#define rrep(i, a, b) for (ll i = (a)-1; i >= (b); i--)

struct Vec {
    double x = 0;
    double y = 0;
    
    Vec() {}
    Vec(double x, double y) : x(x), y(y) {}
    Vec operator+(const Vec& rhs) const { return {x + rhs.x, y + rhs.y}; }
    Vec operator-(const Vec& rhs) const { return {x - rhs.x, y - rhs.y}; }
    Vec operator-() { return {-x, -y}; }
    double operator*(const Vec& rhs) const { return x * rhs.x + y * rhs.y; }
    double cross(const Vec& rhs) const {
        return x * rhs.y - y * rhs.x;
    }
    Vec operator*(double k) const { return {x * k, y * k}; }
    Vec operator/(double k) const { return {x / k, y / k}; }
    double len_sq() const { return (*this) * (*this); }
    double len() const { return sqrt(len_sq()); }
    void rotate() { swap(x, y); x *= -1; } // ToDo: 追加する
    double angle(const Vec& rhs) const {
        double len_prod = len() * rhs.len();
        double c = (*this * rhs) / len_prod;
        double s = (cross(rhs)) / len_prod;
        return atan2(s, c);
    }
    double angle_abs(const Vec& rhs) const {
        return abs(angle(rhs));
    }
    bool operator==(const Vec& rhs) const {
        return x == rhs.x && y == rhs.y;
    }
};

template<>
struct hash<Vec> {
    // ハッシュを計算する
    size_t operator()(const Vec& key) const {
        char buf[16];
        memcpy(buf, &key.x, 8); // ToDo: sizeof
        memcpy(buf + 8, &key.y, 8);
        return hash<string>()(buf);
    }
};

vector<Vec> upper_closure(vector<Vec> pts) {
    sort(pts.begin(), pts.end(), [](const Vec& lhs, const Vec& rhs) {
        return lhs.x < rhs.x || (lhs.x == rhs.x && lhs.y < rhs.y);
    });
    vector<Vec> upper;
    upper.push_back(pts[0]);
    for (ll i = 1; i < pts.size(); i++) {
        while (true) {
            if (upper.size() < 2) {
                break;
            }
            Vec now = pts[i];
            Vec top = upper.back();
            Vec prv = *(upper.end() - 2);
            if (now.x == top.x) {
                if (prv.x == top.x) {
                    break;
                }
            } else {
                if (prv.x == top.x) {
                    break;
                }
                if ((top.y - prv.y) * (now.x - top.x)
                    > (now.y - top.y) * (top.x - prv.x)) {
                    break;
                }
            }
            upper.pop_back();
        }
        upper.push_back(pts[i]);
    }
    return upper;
}

vector<Vec> closure(vector<Vec> pts) {
    if (pts.size() == 1) {
        return pts;
    }
    vector<Vec> upper = upper_closure(pts);
    for (ll i = 0; i < pts.size(); i++) {
        pts[i].x *= -1;
        pts[i].y *= -1;
    }
    vector<Vec> lower = upper_closure(move(pts));
    for (ll i = 0; i < lower.size(); i++) {
        lower[i].x *= -1;
        lower[i].y *= -1;
    }
    upper.pop_back();
    lower.pop_back();
    if (lower.size() > upper.size()) {
        swap(lower, upper);
    }
    copy(lower.begin(), lower.end(), back_inserter(upper));
    return upper;
}

int main() {
    ll N;
    cin >> N;
    vector<Vec> pts(N);
    rep(i,0,N) {
        cin >> pts[i].x >> pts[i].y;
    }
    unordered_map<Vec, double> ans;
    vector<Vec> hull = closure(pts);
    rep(i,0,hull.size()) {
        Vec now(hull[i].x, hull[i].y);
        ll next_idx = (i+1)%hull.size();
        Vec next = hull[next_idx];
        ll prev_idx = i-1;
        if (prev_idx < 0) {
            prev_idx += hull.size();
        }
        prev_idx = prev_idx % hull.size();
        Vec prev = hull[prev_idx];
        Vec v1 = next - now;
        Vec v2 = now - prev;
        ans[now] = v1.angle_abs(v2) / (2.0 * M_PI);
    }
    rep(i,0,N) {
        if (ans.find(pts[i]) != ans.end()) {
            cout << fixed << setprecision(10) << ans[pts[i]] << endl;
        } else {
            cout << 0.0 << endl;
        }
    }
}



Measured memory_bytes: 888