#include <bits/stdc++.h>
#include <algorithm>
#include <array>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define REP(i, n) for (int i = 0; (i) < int(n); ++ (i))
#define REP3(i, m, n) for (int i = (m); (i) < int(n); ++ (i))
#define REP_R(i, n) for (int i = int(n) - 1; (i) >= 0; -- (i))
#define REP3R(i, m, n) for (int i = int(n) - 1; (i) >= int(m); -- (i))
#define ALL(x) begin(x), end(x)
#define dump(x) cerr << #x " = " << x << endl
#define unittest_name_helper(counter) unittest_ ## counter
#define unittest_name(counter) unittest_name_helper(counter)
#define unittest __attribute__((constructor)) void unittest_name(__COUNTER__) ()
using ll = long long;
using namespace std;
template <class T> using reversed_priority_queue = priority_queue<T, vector<T>, greater<T> >;
template <class T> inline void chmax(T & a, T const & b) { a = max(a, b); }
template <class T> inline void chmin(T & a, T const & b) { a = min(a, b); }
template <typename X, typename T> auto vectors(X x, T a) { return vector<T>(x, a); }
template <typename X, typename Y, typename Z, typename... Zs> auto vectors(X x, Y y, Z z, Zs... zs) { auto cont = vectors(y, z, zs...); return vector<decltype(cont)>(x, cont); }
template <typename T> ostream & operator << (ostream & out, vector<T> const & xs) { REP (i, int(xs.size()) - 1) out << xs[i] << ' '; if (not xs.empty()) out << xs.back(); return out; }


constexpr double eps = 1e-8;
typedef complex<double> point;
double cross(point a, point b) { return a.real() * b.imag() - a.imag() * b.real(); }
int ccw(point a, point b, point c) { double z = cross(b - a, c - a); return z > eps ? 1 : z < - eps ? -1 : 0; }

/**
 * @brief Andrew's Monotone Chain, http://www.prefield.com/algorithm/geometry/convex_hull.html
 */
vector<point> convex_hull(vector<point> ps) {
    int n = ps.size();
    sort(ALL(ps), [&](point a, point b) { return make_pair(a.real(), a.imag()) < make_pair(b.real(), b.imag()); });
    vector<point> ch(2 * n);
    int k = 0;
    for (int i = 0; i < n; ch[k ++] = ps[i ++]) // lower-hull
        while (k >= 2 and ccw(ch[k - 2], ch[k - 1], ps[i]) <= 0) -- k;
    for (int i = n - 2, t = k + 1; i >= 0; ch[k ++] = ps[i --]) // upper-hull
        while (k >= t and ccw(ch[k - 2], ch[k - 1], ps[i]) <= 0) -- k;
    ch.resize(k - 1);
    return ch;
}

vector<double> solve(int n, vector<point> const & ps) {
    assert (n >= 2);
    vector<point> qs = convex_hull(ps);
    int k = qs.size();
    vector<double> prob(k);
    if (k == 2) {
        prob[0] = prob[1] = 0.5;
    } else {
        REP (i, k) {
            double a1 = arg(qs[i] - qs[(i + k - 1) % k]);
            double a2 = arg(qs[(i + 1) % k] - qs[i]);
            double a = abs(a1 - a2);
            prob[i] = a / (2 * M_PI);
            if (prob[i] > 0.5) prob[i] = 1 - prob[i];
        }
    }
    vector<double> result(n);
    REP (i, k) {
        int j = find(ALL(ps), qs[i]) - ps.begin();
        result[j] = prob[i];
    }
    return result;
}

int main() {
    // input
    int n; scanf("%d", &n);
    vector<point> ps(n);
    REP (i, n) {
        double x, y;
        scanf("%lf%lf", &x, &y);
        ps[i] = { x, y };
    }
    // solve
    vector<double> result = solve(n, ps);
    // output
    for (auto prob : result) {
        printf("%.12lf\n", prob);
    }
    return 0;
}


Measured memory_bytes: 256