#include <stdio.h>
#include <assert.h>
#include <fstream>
#include <iostream>
#include <algorithm>
#include <array>
#include <vector>
#include <queue>
#include <set>
#include <cmath>
#include <unordered_map>
//#include <unordered_set>
//#include <boost/container/static_vector.hpp>
//#include <boost/unordered_set.hpp>
//#include <boost/unordered_map.hpp>
//#include <unistd.h>

//#include <cv.h>
//#include <highgui.h>
#include <stdlib.h>
#include <time.h>
#include <iomanip>
#include <string>

const double EPS = 1e-10;

// 誤差を考慮して足し算を行う
double add(const double a, const double b) {
    if (fabs(a + b) < EPS * (fabs(a) + fabs(b))) {
        return 0;
    } else {
        return a + b;
    }
}

struct Point_Int {
    int x, y, id;
    Point_Int() {}
    Point_Int(int x, int y, int id) : x(x), y(y), id(id) {}
};

// 二次元ベクトル構造体
struct Point {
    double x, y;
    int id;
    Point() {}
    Point(double x, double y, int id) : x(x), y(y), id(id) {}
    Point operator + (Point p) {
        return Point(add(x, p.x), add(y, p.y), -1);
    }
    Point operator - (Point p) {
        return Point(add(x, -p.x), add(y, -p.y), -1);
    }
    Point operator * (const double d) {
        return Point(x * d, y * d, -1);
    }
    double dot(const Point p) { // 内積
        return add(x * p.x, y * p.y);
    }
    double det(const Point p) { // 外積
        return add(x * p.y, -y * p.x);
    }
};

// 辞書順で比較
bool cmp_x(const Point& p, const Point& q) {
    if (p.x != q.x) {
        return p.x < q.x;
    } else {
        return p.y < q.y;
    }
}

// 凸包を求める
//std::vector<Point> convex_hull(Point* ps, const int n) {
std::vector<Point> convex_hull(std::vector<Point> ps, const int n) {
    // Pointでのsortはdouble型で不安なため、整数方のうちにソートしておく方が望ましい気がする…。
    //std::sort(ps, ps + n, cmp_x);
    int k = 0;  // 凸包の頂点数
    std::vector<Point> qs(n*2); // 構築中の凸包

    // 下側凸包の作成
    for (int i = 0; i < n; i++) {
        while (k > 1 && (qs[k-1] - qs[k-2]).det(ps[i] - qs[k-1]) <= 0) {
            // qs[k-2] -> qs[k-1] -> ps[i] と進む際に時計周りに回転する場合（qs[k-1]がいらないのでkを減らすことで、qs[k-1]を置き換える。）
            k--;
        }
        qs[k++] = ps[i];
    }

    // 上側凸包の作成
    for (int i = n - 2, t = k; i >= 0; i--) {
        while (k > t && (qs[k-1] - qs[k-2]).det(ps[i] - qs[k-1]) <= 0) {
            k--;
        }
        qs[k++] = ps[i];
    }

    // この時、qs[k-1]は上側凸包を作成した際にps[0]が入っていて、不要なので削る。
    qs.resize(k-1);
    return qs;
}

// 距離の2乗
double dist(Point p, Point q) {
    return (p - q).dot(p - q);
}

const int MAX_N = 300;
int N;
int x[MAX_N], y[MAX_N];

double ret[MAX_N] = {};

std::vector<Point_Int> int_vec;
std::vector<Point> point_vec;

int main(int argc, char **argv) {
    std::cin >> N;

    for (int i = 1; i <= N; i++) {
        std::cin >> x[i] >> y[i];
    }

    if (N == 2) {
        std::cout << 0.5 << std::endl;
        std::cout << 0.5 << std::endl;
        return 0;
    }

    for (int i = 1; i <= N; i++) {
        int_vec.push_back(Point_Int(x[i], y[i], i));
    }

    std::sort(int_vec.begin(), int_vec.end(),
        [](const Point_Int& a, const Point_Int& b) { 
            if (a.x != b.x) {
                return a.x < b.x;
            } else {
                return a.y < b.y;
            }
        }
    );

    for (auto p : int_vec) {
        Point point = Point(p.x, p.y, p.id);
        point_vec.push_back(point);
    }

    std::vector<Point> ch = convex_hull(point_vec, point_vec.size());

    if (ch.size() == 2) {
        ret[ch[0].id] = 0.5;
        ret[ch[1].id] = 0.5;
    } else {
        const double pi = std::acos(-1.0);
        for (int i = 0; i < ch.size(); i++) {
            int prev = i == 0 ? ch.size() - 1 : i - 1;
            int next = i == ch.size() - 1 ? 0 : i + 1;

            Point v1 = ch[prev] - ch[i];
            Point v2 = ch[next] - ch[i];

            double tmp_cos = v1.dot(v2) / sqrt(dist(ch[prev], ch[i])) / sqrt(dist(ch[next], ch[i]));
            double angle = pi - std::acos(tmp_cos);
        
            ret[ch[i].id] = angle / pi / 2.0;
        }
    }

    for (int i = 1; i <= N; i++) {
        std::cout << std::setprecision(10) << ret[i] << std::endl;
    }

    return 0;
}

Measured memory_bytes: 512