/*
* C++11 code template for contests.
* @author: Andrei Kalendarov
* @e-mail: andreykalendarov@gmail.com
*/

//#define ANDREIKKAA_ALLOCATOR
const int _ML = 250;

const char _inpf[] =
#if defined(ANDREIKKAA)
        "input.txt"
#else
""
#endif
;
const char _outf[] =
#if defined(ANDREIKKAA)
        ""
#else
""
#endif
;

#if defined(ANDREIKKAA)
#undef NDEBUG
#else
#pragma GCC optimize("O3,no-stack-protector")
#endif
#include <bits/stdc++.h>
#if !defined(ANDREIKKAA)
#define endl '\n'
#endif
#define x first
#define y second
using namespace std;
#define rand abcdefghijklmnopqrstuvwxyz
#define random_shuffle abcdefghijklmnopqrstuvwxyz
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()
typedef long long ll;
typedef long double ld;
const ld PI = 3.14159265358979323846;
mt19937 rd(228);
#if defined(ANDREIKKAA_ALLOCATOR)
char _mem[_ML * 1024 * 1024];
size_t _ptr = 0;
inline void* operator new (size_t _x) { _ptr += _x; assert(_ptr < _ML * 1024 * 1024); return _mem + _ptr - _x; }
inline void operator delete (void*) { }
#endif
template<typename T, typename U> inline ostream &operator<< (ostream &_out, const pair<T, U> &_p) { _out << _p.first << ' ' << _p.second; return _out; }
template<typename T, typename U> inline istream &operator>> (istream &_in, pair<T, U> &_p) { _in >> _p.first >> _p.second; return _in; }
template<typename T> inline ostream &operator<< (ostream &_out, const vector<T> &_v) { if (_v.empty()) { return _out; } _out << _v.front(); for (auto _it = ++_v.begin(); _it != _v.end(); ++_it) { _out << ' ' << *_it; } return _out; }
template<typename T> inline istream &operator>> (istream &_in, vector<T> &_v) { for (auto &_i : _v) { _in >> _i; } return _in; }
template<typename T> inline ostream &operator<< (ostream &_out, const set<T> &_s) { if (_s.empty()) { return _out; } _out << *_s.begin(); for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) { _out << ' ' << *_it; } return _out; }
template<typename T> inline ostream &operator<< (ostream &_out, const multiset<T> &_s) { if (_s.empty()) { return _out; } _out << *_s.begin(); for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) { _out << ' ' << *_it; } return _out; }
template<typename T> inline ostream &operator<< (ostream &_out, const unordered_set<T> &_s) { if (_s.empty()) { return _out; } _out << *_s.begin(); for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) { _out << ' ' << *_it; } return _out; }
template<typename T> inline ostream &operator<< (ostream &_out, const unordered_multiset<T> &_s) { if (_s.empty()) { return _out; } _out << *_s.begin(); for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) { _out << ' ' << *_it; } return _out; }
template<typename T, typename U> inline ostream &operator<< (ostream &_out, const map<T, U> &_m) { if (_m.empty()) { return _out; } _out << '(' << _m.begin()->first << ": " << _m.begin()->second << ')'; for (auto _it = ++_m.begin(); _it != _m.end(); ++_it) { _out << ", (" << _it->first << ": " << _it->second << ')'; } return _out; }
template<typename T, typename U> inline ostream &operator<< (ostream &_out, const unordered_map<T, U> &_m) { if (_m.empty()) { return _out; } _out << '(' << _m.begin()->first << ": " << _m.begin()->second << ')'; for (auto _it = ++_m.begin(); _it != _m.end(); ++_it) { _out << ", (" << _it->first << ": " << _it->second << ')'; } return _out; }

/* ________ CODE ________ */

const ld EPS = 1e-9;

struct pt
{
    ld x, y;
    int clr;

    ld len()
    {
        return sqrt(x * x + y * y);
    }
};

ld operator*(pt a, pt b)
{
    return a.x * b.y - a.y * b.x;
}

int sgn(ld x)
{
    if(x < -EPS)
    {
        return -1;
    }
    if(x > EPS)
    {
        return 1;
    }
    return 0;
}


pt vec(pt a, pt b)
{
    return{b.x - a.x, b.y - a.y};
}

vector<pt> conv(vector<pt> a)
{
    pt mn = *min_element(all(a), [](const pt &a, const pt &b)
    {
        if(a.x != b.x)
        {
            return a.x < b.x;
        }
        return a.y < b.y;
    });

    sort(all(a), [=](const pt &a, const pt &b)
    {
        if(sgn(vec(mn, a) * vec(mn, b)) == 0)
        {
            return vec(mn, a).len() < vec(mn, b).len();
        }
        return sgn(vec(mn, a) * vec(mn, b)) == 1;
    });

    vector<pt> ans;

    for(pt i : a)
    {
        while(sz(ans) >= 2 && sgn(vec(ans[sz(ans) - 2], ans.back()) * vec(ans.back(), i)) != 1)
        {
            ans.pop_back();
        }
        ans.push_back(i);
    }

    return ans;
}

inline void _main_function()
{
    int n;
    cin >> n;
    int nn = n;

    vector<pt> a(n);
    vector<ld> ans(n);
    for(int i = 0; i < n; ++i)
    {
        cin >> a[i].x >> a[i].y;
        a[i].clr = i;
    }

    a = conv(a);
    n = sz(a);

    assert(n > 1);

    for(int i = 0; i < n; ++i)
    {
        int pr = (i - 1 + n) % n;
        int nx = (i + 1) % n;
        ld a1 = atan2(-a[pr].x + a[i].x, a[pr].y - a[i].y);
        ld a2 = atan2(a[nx].x - a[i].x, -a[nx].y + a[i].y);
        ld diff = min(abs(a2 - a1), 2 * PI - abs(a2 - a1));
        ans[a[i].clr] = diff / (2 * PI);
    }

    for(int i = 0; i < nn; ++i)
    {
        cout << ans[i] << endl;
    }
}

/* ________ CODE ________ */

int main()
{
#if defined(ANDREIKKAA)
    time_t _start = clock();
#endif
    if (_inpf[0] != '\0') assert(freopen(_inpf, "r", stdin) != nullptr);
    if (_outf[0] != '\0') assert(freopen(_outf, "w", stdout) != nullptr);
    cin.tie(nullptr);
    ios_base::sync_with_stdio(false);

    cout << setprecision(20);
    cout << fixed;

    _main_function();
#if defined(ANDREIKKAA)
    cout << "Time: " << (clock() - _start) / (ld)CLOCKS_PER_SEC << endl;
#endif
}


Measured memory_bytes: 256