#include <iostream>
#include <cmath>
#include <vector>
#include <iomanip>
#include <algorithm>

using namespace std;

#define double long double

const double EPS = 1e-8;
const double PI = acos(-1);

double sqr(double a) {
    return a * a;
}

bool dEqual(double a, double b) {
    return fabs(a - b) < EPS;
}

bool dLess(double a, double b) {
    return a < b && !dEqual(a, b);
}

bool dLessOrEqual(double a, double b) {
    return a < b || dEqual(a, b);
}

bool dGereater(double a, double b) {
    return a > b && !dEqual(a, b);
}

bool dGreaterOrEqual(double a, double b) {
    return a > b || dEqual(a, b);
}

struct Point;
struct Vector;

struct Point {
    double x, y;
    int ind;

    Point(double x = 0, double y = 0) : x(x), y(y) {}

    Point operator+(const Vector &a) const;

    Point &operator+=(const Vector &a);

    Point operator-(const Vector &a) const;

    Point &operator-=(const Vector &a);

    double distTo(const Point &a) const; // dist to point a
    double distTo(const Point &a, const Point &b) const; // dist to line(a, b)
    Point getH(const Point &a, const Point &b) const; // h from this to line(a, b)
    bool isOnLine(const Point &a, const Point &b) const; // this is on line(a, b)?
    bool isInSegment(const Point &a, const Point &b) const; // this is in segment(a, b)?
    bool isInSegmentStrictly(const Point &a, const Point &b) const;
};

struct Vector {
    double x, y;

    Vector(double x = 0, double y = 0) : x(x), y(y) {}

    Vector(const Point &a, const Point &b) :
            x(b.x - a.x), y(b.y - a.y) {}

    Vector operator+(const Vector &a);

    Vector &operator+=(const Vector &a);

    Vector operator-(const Vector &a) const;

    Vector &operator-=(const Vector &a);

    Vector operator*(double k) const;

    Vector &operator*=(double k);

    Vector operator/(double k) const;

    Vector &operator/=(double k);

    double operator*(const Vector &a) const;

    double operator%(const Vector &a) const;

    bool isZero() const;

    double len() const;

    void norm(double k = 1);

    void rotate(); // rotate 90(ccw, 3*rotate() => cw)
    void rotate(double cosa, double sina); // rotate cos, sin
    void rotate(double alph); // rotate alph(ccw, alph < 0 => cw)
    double getAngle() const; // get polar angle
    double getAngle(const Vector &u) const;
};

Point Point::operator+(const Vector &a) const {
    return Point(x + a.x, y + a.y);
}

Point &Point::operator+=(const Vector &a) {
    x += a.x, y += a.y;
    return *this;
}

Point Point::operator-(const Vector &a) const {
    return Point(x - a.x, y - a.y);
}

Point &Point::operator-=(const Vector &a) {
    x -= a.x, y -= a.y;
    return *this;
}

Vector Vector::operator+(const Vector &a) {
    return Vector(x + a.x, y + a.y);
}

Vector &Vector::operator+=(const Vector &a) {
    x += a.x, y += a.y;
    return *this;
}

Vector Vector::operator-(const Vector &a) const {
    return Vector(x - a.x, y - a.y);
}

Vector &Vector::operator-=(const Vector &a) {
    x -= a.x, y -= a.y;
    return *this;
}

Vector Vector::operator*(double k) const {
    return Vector(x * k, y * k);
}

Vector &Vector::operator*=(double k) {
    x *= k, y *= k;
    return *this;
}

Vector Vector::operator/(double k) const {
    return Vector(x / k, y / k);
}

Vector &Vector::operator/=(double k) {
    x /= k, y /= k;
    return *this;
}

double Vector::operator%(const Vector &a) const {
    return x * a.x + y * a.y;
}

double Vector::operator*(const Vector &a) const {
    return x * a.y - y * a.x;
}

double Vector::len() const {
    return sqrt(*this % *this);
}

void Vector::norm(double k) {
    *this *= k / len();
}

void Vector::rotate() {
    swap(x, y);
    x = -x;
}

void Vector::rotate(double alph) {
    rotate(cos(alph), sin(alph));
}

void Vector::rotate(double cosa, double sina) {
    Vector v = *this;
    auto u = v;
    u.rotate();
    *this = v * cosa + u * sina;
}

double Vector::getAngle() const {
    return atan2(y, x);
}

double Vector::getAngle(const Vector &u) const {
    Vector v = *this;
    return atan2(v * u, v % u); // sin, cos
}

bool Vector::isZero() const {
    return dEqual(x, 0) && dEqual(y, 0);
}

double Point::distTo(const Point &a) const {
    return Vector(*this, a).len();
}

double Point::distTo(const Point &a, const Point &b) const {
    double d = a.distTo(b);
    double s = Vector(a, *this) * Vector(b, *this);
    return fabs(s) / d;
}

Point Point::getH(const Point &a, const Point &b) const {
    Point c = *this;
    Vector v(a, b), u(a, c);
    double k = v % u / v.len();
    v.norm(k);
    return a + v;
}

bool Point::isOnLine(const Point &a, const Point &b) const {
    return dEqual(Vector(*this, a) * Vector(*this, b), 0);
}

bool Point::isInSegment(const Point &a, const Point &b) const {
    return isOnLine(a, b) && dLessOrEqual(Vector(*this, a) % Vector(*this, b), 0);
}

bool Point::isInSegmentStrictly(const Point &a, const Point &b) const {
    return isOnLine(a, b) && dLess(Vector(*this, a) % Vector(*this, b), 0);
}

int getIntersection(const Point &a, const Point &b, // line(a, b, line(c, d), res in o
                    const Point &c, const Point &d, // returns num of inters points (2 == inf)
                    Point &o) {
    Vector v(a, b);
    double s1 = Vector(a, c) * Vector(a, d);
    double s2 = Vector(b, d) * Vector(b, c);
    double s = s1 + s2;
    if (dEqual(s, 0)) {
        if (!a.isOnLine(c, d)) {
            return 0;
        }
        return 2;
    }
    v = v / s;
    v = v * s1;
    o = a + v;
    return 1;
}

int getIntersection(const Point &a, double rA, const Point &b, double rB,
                    Point &m, Point &n) { // circle(a, rA), circle(b, rB)
    double d = a.distTo(b);
    if (dLess(rA + rB, d) || dLess(d, fabs(rA - rB))) {
        return 0;
    }
    double la = (sqr(rA) - sqr(rB) + sqr(d)) / 2 /
                d; // длину проекции отрезка (от A до пересечения окружностей) на прямую AB
    double lh = sqr(sqr(rA) - sqr(la)); //расстояние о точки пересечения окружностей до прямой AB
    Vector v(a, b), u(a, b); //направляющий вектор прямой AB
    u.rotate(); // нормальный вектор к прямой AB
    v.norm(la);
    u.norm(lh); //нормируем до нужных длин оба вектора
    Point h = a + v;
    m = h + u, n = h - u;
    if (u.isZero()) return 1; //если u = 0, то окружности касаются
    return 2;
}

int getIntersection(const Point &a, const Point &b, // line(a, b), circle(o, r)
                    const Point &o, double r,
                    Point &m, Point &n) {
    double h = o.distTo(a, b);
    if (dLess(r, h)) {//если окружность далеко от прямой
        return 0;
    }
    Point H = o.getH(a, b); //уронили высоту на AB
    Vector v(a, b); //взяли направляющий вектор прямой
    double k = sqrt(sqr(r) - sqr(h)); // величина, на которую надо подвинуть H до точки пересечения окружности и прямой
    v.norm(k);
    m = H + v;
    n = H - v;
    if (v.isZero()) return 1;
    return 2;
}

istream &operator>>(istream &in, Point &a) {
    in >> a.x >> a.y;
    return in;
}

ostream &operator<<(ostream &out, Point a) {
    out << a.x << " " << a.y;
    return out;
}


bool cw(const Point &o, const Point &a, const Point &b) {
    Vector oa(o, a), ob(o, b);
    return oa * ob <= 0;
}

void convexHull(vector<Point> &a) {
    sort(a.begin(), a.end(), [&](const Point &p, const Point &q) {
        return p.x < q.x || (p.x == q.x && p.y < q.y);
    });
    vector<Point> res;
    vector<Point> c;
    for (int j = 0; j < 2; ++j) {
        c.clear();
        c.push_back(a[0]);
        for (int i = 1; i < a.size(); ++i) {
            if (i == a.size() - 1 || cw(a[0], a[i], a.back())) {
                while (c.size() > 1 && cw(c[c.size() - 2], a[i], c[c.size() - 1])) {
                    c.pop_back();
                }
                c.push_back(a[i]);
            }
            a[i].y = -a[i].y;
        }
        a[0].y = -a[0].y;
        if (!j) {
            for (auto cc : c) {
                res.push_back(cc);
            }
        }
    }
    for (int i = c.size() - 2; i > 0; --i) {
        c[i].y = -c[i].y;
        res.push_back(c[i]);
    }
    a = res;
}

template<typename T>
istream &operator>>(istream &in, vector<T> &a) {
    for (auto &item : a) {
        in >> item;
    }
    return in;
}

template<typename T>
ostream &operator<<(ostream &out, vector<T> &a) {
    for (auto &item : a) {
        out << item << " ";
    }
    return out;
}

template<typename T>
ostream &operator<<(ostream &out, vector<vector<T>> &a) {
    for (auto &item : a) {
        out << item << "\n";
    }
    return out;
}

int main() {
    int n;
    cin >> n;
    vector<Point> a(n);
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
        a[i].ind = i;
    }
    convexHull(a);
    vector<double> ans(n, 0);
    int m = a.size();
    for (int i = 0; i < m; ++i) {
        Vector prev(a[(i - 1 + m) % m], a[i]);
        Vector nt(a[i], a[(i + 1) % m]);
        prev.rotate();
        nt.rotate();
        ans[a[i].ind] = fabsl(nt.getAngle(prev) / (2 * PI));
    }
    cout << fixed << setprecision(9);
    for (int i = 0; i < n; ++i) {
        cout << ans[i] << "\n";
    }
    return 0;
}

Measured memory_bytes: 256