#include <bits/stdc++.h>
#define SORT(x) sort((x).begin(), (x).end())
#define ALL(x) (x).begin(), (x).end()
#define rep(i, n) for (ll i = 0; i < n; i++)
#define reps(i, m, n) for (ll i = m; i < n; i++)
#define repr(i, m, n) for (ll i = m; i >= n; i--)
#define de(x) cout << #x << "=" << x << endl;
template <class T> bool maxi(T &a, const T &b) {
    if (a < b) { a = b; return 1;} return 0;}
template <class T> bool mini(T &a, const T &b) {
    if (b < a) { a = b; return 1;} return 0;}
#define dame {cout<< "Yes" <<"\n"; return;}
#define INF2 1000000000000000037
#define INF  1000000007
#define MOD  1000000007
using namespace std;
using ll = long long;
using ld = long double;
using P  = pair<ll,ll>;
//--GLOBAL--------------------------------- 
const ld INFL=1LL<<60;
const ld EPS=1e-9;
const ld PI=acosl(-1.0);
ld todeg(ld rad) {return rad*180/PI;}
ld torad(ll deg) {return (ld)(deg)*PI/180;}

struct Point {
    ld x,y;
    Point(ld x = 0.0, ld y = 0.0) : x(x), y(y) {}
    friend ostream& operator << (ostream &s, const Point &p) {return s << '(' << p.x << ", " << p.y << ')';}
};
inline Point operator + (const Point &p, const Point &q) {return Point(p.x + q.x, p.y + q.y);}
inline Point operator - (const Point &p, const Point &q) {return Point(p.x - q.x, p.y - q.y);}
inline Point operator * (const Point &p, ld a) {return Point(p.x * a, p.y * a);}
inline Point operator * (ld a, const Point &p) {return Point(a * p.x, a * p.y);}
inline Point operator * (const Point &p, const Point &q) {return Point(p.x * q.x - p.y * q.y, p.x * q.y + p.y * q.x);} //外積
inline Point operator / (const Point &p, ld a) {return Point(p.x / a, p.y / a);}
inline Point conj(const Point &p) {return Point(p.x, -p.y);} //共役
inline Point rot(const Point &p, ld ang) {return Point(cos(ang) * p.x - sin(ang) * p.y, sin(ang) * p.x + cos(ang) * p.y);}
inline Point rot90(const Point &p) {return Point(-p.y, p.x);}
inline Point midl(const Point &p, const Point &q) {return Point((p.x+q.x)/2, (p.y+q.y)/2);}
inline ld cross(const Point &p, const Point &q) {return p.x * q.y - p.y * q.x;} //内積
inline ld dot(const Point &p, const Point &q) {return p.x * q.x + p.y * q.y;} //各点積
inline ld norm(const Point &p) {return dot(p, p);}
inline ld abs(const Point &p) {return sqrt(dot(p, p));}
inline ld ang(const Point &p) {ld res = atan2(p.y, p.x); if (res < 0) res += PI*2; return res;} //角度 rad
inline bool eq(const Point &p, const Point &q) {return abs(p - q) < EPS;}
inline bool operator < (const Point &p, const Point &q) {return (abs(p.x - q.x) > EPS ? p.x < q.x : p.y < q.y);} // x->y の順
inline bool operator > (const Point &p, const Point &q) {return (abs(p.x - q.x) > EPS ? p.x > q.x : p.y > q.y);}

vector<Point> unique(vector<Point> ps){
    SORT(ps);
    vector<Point> res;
    for(Point p: ps){
        if(res.empty() or abs(res.back()-p) > EPS) res.emplace_back(p);
    }
    return res;
}

struct Line : vector<Point> {
    Line(Point a = Point(0.0, 0.0), Point b = Point(0.0, 0.0)) {
        this->emplace_back(a);
        this->emplace_back(b);
    }
    friend ostream& operator << (ostream &s, const Line &l) {return s << '{' << l[0] << ", " << l[1] << '}';}
};

struct Circle : Point {
    ld r;
    Circle(Point p = Point(0.0, 0.0), ld r = 0.0) : Point(p), r(r) {}
    friend ostream& operator << (ostream &s, const Circle &c) {return s << '(' << c.x << ", " << c.y << ", " << c.r << ')';}
};

// 1：a->b向きでcが左(反時計)、-1：cはが右(時計)、0：一直線上
int pointside(const Point &a, const Point &b, const Point &c) {
    if (cross(b-a, c-a) > EPS) return 1;
    if (cross(b-a, c-a) < -EPS) return -1;
    /*
    if(dot(b-a, c-a) < 0) return 2; // c-a-b
    if(norm(b-a) < norm(c-a)) return -2; // a-b-c else a-c-b
    */
    return 0;
}

// Lineの交点。線分や曲線なら書き換え
vector<Point> crosspoint(const Line &l, const Line &m) {
    vector<Point> res;
    ld d = cross(m[1] - m[0], l[1] - l[0]);
    if (abs(d) < EPS) return vector<Point>();
    res.push_back(l[0] + (l[1] - l[0]) * cross(m[1] - m[0], m[1] - l[0]) / d);
    return res;
}

// 3点から等距離の点  if(pointside(a,b,c)==0) skip;
Point centerpoint(Point a, Point b, Point c) {
    Line ab((a+b)/2, (a+b)/2 + rot90(a-b));
    Line bc((b+c)/2, (b+c)/2 + rot90(b-c));
    return crosspoint(ab, bc)[0];
}

// 凸包
vector<pair<Point, int> > ConvexHull(vector<pair<Point, int>> &ps) {
    int n = ps.size();
    vector<pair<Point, int> > res(2*n);
    SORT(ps);
    int k = 0;
    for (int i = 0; i < n; ++i) { // 下凸包を左下から右に調べる
        if (k >= 2) {
            while (cross(res[k-1].first - res[k-2].first, ps[i].first - res[k-2].first) < EPS) { //中間が上なら中間を取り除く
                --k;
                if (k < 2) break;
            }
        }
        res[k].first = ps[i].first; res[k].second = ps[i].second;
        ++k;
    }
    int t = k+1; // 下凸包は決定、次の1個は入れる
    for (int i = n-2; i >= 0; --i) { // 上凸包を右上から左に調べる
        if (k >= t) {
            while (cross(res[k-1].first - res[k-2].first, ps[i].first - res[k-2].first) < EPS) {
                --k;
                if (k < t) break;
            }
        }
        res[k].first = ps[i].first; res[k].second = ps[i].second;
        ++k;
    }
    res.resize(k-1); //最後は最初と同じなので除く
    return res;
}

// from end.

//--MAIN-----------------------------------
void Main() {
    ll N; cin>>N;
    vector<pair<Point, int>> poi(N);
    rep(i,N) cin>>poi[i].first.x>>poi[i].first.y;
    rep(i,N) poi[i].second=i;

    auto ch=ConvexHull(poi);

    ll M=ch.size();

    vector<ld> ans(N,0);

    rep(i,M){
        ld ang1=ang(rot90(ch[((i-1)+M)%M].first-ch[i].first));
        ld ang2=ang(rot90(ch[i].first-ch[((i+1)+M)%M].first));
        ld ang3=ang2-ang1;
        if(ang3<0) ang3+=PI*2;
        ans[ch[i].second]=ang3/(PI*2);
    }

    rep(i,N){
        cout<< ans[i] <<"\n";
    }

}

//--START----------------------------------
int main() {
    cin.tie(nullptr);
    ios_base::sync_with_stdio(false);
    cout << fixed << setprecision(15);
    Main();
}
//-----------------------------------------


Measured memory_bytes: 256