// {{{ by shik
#include <bits/stdc++.h>
#pragma GCC diagnostic ignored "-Wunused-result"
#pragma GCC diagnostic ignored "-Wunused-function"
#define SZ(x) ((int)(x).size())
#define ALL(x) begin(x), end(x)
#define REP(i, n) for (int i = 0; i < int(n); i++)
#define REP1(i, a, b) for (int i = (a); i <= int(b); i++)
#define MP make_pair
#define PB push_back
using namespace std;
typedef int64_t LL;
typedef pair<int, int> PII;
typedef vector<int> VI;

namespace { namespace shik {

template<class T> void _R(T &x) { cin >> x; }
void _R(int &x) { scanf("%d", &x); }
void _R(int64_t &x) { scanf("%" SCNd64, &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template<class T, class... U> void R(T &head, U &... tail) { _R(head); R(tail...); }

template<class T> void _W(const T &x) { cout << x; }
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%" PRId64, x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template<class T> void _W(const vector<T> &x) { for (auto i = x.begin(); i != x.end(); _W(*i++)) if (i != x.cbegin()) putchar(' '); }
void W() {}
template<class T, class... U> void W(const T &head, const U &... tail) { _W(head); putchar(sizeof...(tail) ? ' ' : '\n'); W(tail...); }

#ifdef SHIK
#include "dump.hpp"
#else
#define dump(...)
#endif

template<class T, class F = less<T>> void sort_uniq(vector<T> &v, F f = F()) { sort(begin(v), end(v), f); v.resize(unique(begin(v), end(v)) - begin(v)); }
template<class T> inline T bit(T x, int i) { return (x >> i) & 1; }
template<class T> inline bool chkmax(T &a, const T &b) { return b > a ? a = b, true : false; }
template<class T> inline bool chkmin(T &a, const T &b) { return b < a ? a = b, true : false; }
template<class T> using MaxHeap = priority_queue<T>;
template<class T> using MinHeap = priority_queue<T, vector<T>, greater<T>>;

// }}}

typedef long double Double;
const Double pi = acos(Double(-1));
const Double eps = 1e-8;

int sgn(Double x, Double e = eps) { return (x > +e) - (x < -e); }
int cmp(Double x, Double y, Double e = eps) { return sgn(x - y, e); }

Double sqr(Double x) { return x * x; }

struct Point {
    Double x, y;
    Double len2() const { return x * x + y * y; }
    Double len() const { return sqrt(len2()); }
    Double ang() const { return atan2(y,x); }
    bool operator<(const Point &rhs) const { return tie(x, y) < tie(rhs.x, rhs.y); }
    bool operator==(const Point &rhs) const { return x == rhs.x && y == rhs.y; }
    Point operator-() const { return {-x, -y}; }
    Point operator+(const Point &rhs) const { return {x + rhs.x, y + rhs.y}; }
    Point operator-(const Point &rhs) const { return {x - rhs.x, y - rhs.y}; }
    Point operator*(Double rhs) const { return {x * rhs, y * rhs}; }
    Point operator/(Double rhs) const { return {x / rhs, y / rhs}; }
    Point& operator+=(const Point &rhs) { return *this = *this + rhs; }
    Point& operator-=(const Point &rhs) { return *this = *this - rhs; }
    Point& operator*=(Double rhs) { return *this = *this * rhs; }
    Point& operator/=(Double rhs) { return *this = *this / rhs; }
    friend istream& operator>>(istream &is, Point &p) { return is >> p.x >> p.y; }
    friend ostream& operator<<(ostream &os, const Point &p) { return os << '(' << p.x << ',' << p.y << ')'; }
};

Point unit(const Point &p) { return p / p.len(); }
Point rotate_90(const Point &p) { return {-p.y, p.x}; }
Point rotate_180(const Point &p) { return {-p.x, -p.y}; }
Point rotate_270(const Point &p) { return {p.y, -p.x}; }
Point rotate(const Point &p, Double t) { return {p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t)}; }
Double dot(const Point &p, const Point &q) { return p.x * q.x + p.y * q.y; }
Double cross(const Point &p, const Point &q) { return p.x * q.y - q.x * p.y; }
Double cross(const Point &o, const Point &p, const Point &q) { return cross(p - o, q - o); }
Double dis(const Point &p, const Point &q) { return (p - q).len(); }
Double dis2(const Point &p, const Point &q) { return (p - q).len2(); }

int cmp(const Point &p, const Point &q, Double e = eps) {
    auto cx = cmp(p.x, q.x, e);
    return cx != 0 ? cx : cmp(p.y, q.y, e);
}

Double disPL(const Point &p, const Point &q1, const Point &q2) { return abs(cross(p, q1, q2)) / dis(q1, q2); }

int jiaoCC(const Point &p, Double pr, const Point &q, Double qr, Point *out) { // TODO: eps?
    if (p == q && pr == qr) return -1;
    auto d2 = dis2(p, q);
    if (d2 < sqr(pr - qr)) return 0;
    if (d2 > sqr(pr + qr)) return 0;
    auto a = ((pr * pr - qr * qr) / d2 + 1) / 2;
    auto b = pr * pr / d2 - a * a;
    if (b < 0) b = 0;
    auto u = p + (q - p) * a;
    auto v = rotate_90((q - p) * sqrt(b));
    out[0] = u + v;
    out[1] = u - v;
    return 2;
}

typedef Point P;

const int N=110;
int n;
P p[N];

void main() {
    R(n);
    REP(i,n) R(p[i].x,p[i].y);
    REP(i,n) {
        Double l=-100,r=+100;
        REP(j,n) if ( i!=j ) {
            P d=rotate_90(p[j]-p[i]);
            auto a=d.ang();
            while ( a+pi<l ) a+=2*pi;
            while ( a>r ) a-=2*pi;
            chkmax(l,a);
            chkmin(r,a+pi);
        }
        if ( l<r ) {
            auto ans=(r-l)/(2*pi);
            W((double)ans);
        } else {
            W(0.0);
        }
    }
}

// {{{ main
}}
int main() { shik::main(); return 0; }
// }}}


Measured memory_bytes: 256