#include <bits/stdc++.h>

#define M_PI       3.14159265358979323846   // pi

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<ll> VI;
typedef pair<double, double> P;
typedef tuple<ll, ll, ll> t3;
typedef tuple<ll, ll, ll, ll> t4;
typedef tuple<ll, ll, ll, ll, ll> t5;

#define rep(a,n) for(ll a = 0;a < n;a++)
#define repi(a,b,n) for(ll a = b;a < n;a++)

using namespace std;

static const ll INF = 1e15;

struct Point {
	double x, y;

	int id;

	bool operator <(const Point& p) const {
		return x < p.x || (x == p.x && y < p.y);
	}
};

struct ConvexHullRunner {
	typedef double coord_t;
	typedef double coord2_t;

	coord2_t cross(const Point& O, const Point& A, const Point& B)
	{
		return (A.x - O.x) * (B.y - O.y) - (A.y - O.y) * (B.x - O.x);
	}

	vector<Point> convex_hull(vector<Point> P)
	{
		size_t n = P.size(), k = 0;
		if (n <= 3) return P;
		vector<Point> H(2 * n);

		sort(P.begin(), P.end());

		for (size_t i = 0; i < n; ++i) {
			while (k >= 2 && cross(H[k - 2], H[k - 1], P[i]) <= 0) k--;
			H[k++] = P[i];
		}

		for (size_t i = n - 1, t = k + 1; i > 0; --i) {
			while (k >= t && cross(H[k - 2], H[k - 1], P[i - 1]) <= 0) k--;
			H[k++] = P[i - 1];
		}

		H.resize(k - 1);
		return H;
	}
};

struct vector2d {
	double x, y;
	vector2d() :x(0), y(0) {}
	vector2d(double x, double y) : x(x), y(y) {}

	static double distanceSquare(const vector2d& v1, const vector2d& v2) {
		double dx = v1.x - v2.x;
		double dy = v1.y - v2.y;
		return dx * dx + dy * dy;
	}

	static double distance(const vector2d& v1, const vector2d& v2) {
		return sqrt(distanceSquare(v1, v2));
	}

	vector2d sub(vector2d p2) const {
		return vector2d(x - p2.x, y - p2.y);
	}

	vector2d add(vector2d p2) const {
		return vector2d(x + p2.x, y + p2.y);
	}

	double distance(vector2d p2) const {
		return sqrt((x - p2.x) * (x - p2.x) + (y - p2.y) * (y - p2.y));
	}

	vector2d normal() const {
		double length = norm();
		return vector2d(x / length, y / length);
	}

	vector2d scale(float s) const {
		return vector2d(x * s, y * s);
	}
	double norm() const {
		return sqrt(x * x + y * y);
	}

	vector2d operator+(const vector2d& p) const { return vector2d(x + p.x, y + p.y); }
	vector2d operator-(const vector2d& p) const { return vector2d(x - p.x, y - p.y); }
	vector2d operator*(double a) const { return vector2d(x * a, y * a); }
	vector2d Rot90() const { return { -y, x }; }
};

int main() {
	ll n;
	cin >> n;
	vector<Point> ps(n);
	rep(i, n) {
		cin >> ps[i].x >> ps[i].y;
		ps[i].id = i;
	}
	if (n == 2) {
		cout << 0.5 << endl;
		cout << 0.5 << endl;
		return 0;
	}

	ConvexHullRunner r;
	auto h = r.convex_hull(ps);
	auto hullSize = h.size();
	h.insert(h.end(), h.begin(), h.end());
	int start = 1;
	int end = hullSize;
	vector<double> as(n, 0);
	for (int i = start; i <= end; i++) {
		int prev = i - 1;
		int next = i + 1;
		auto v1 = vector2d(h[prev].x, h[prev].y);
		auto v2 = vector2d(h[i].x, h[i].y);
		auto v3 = vector2d(h[next].x, h[next].y);
		auto d1 = (v2 - v1).normal().Rot90();
		auto d2 = (v3 - v2).normal().Rot90();
		auto r1 = atan2(d1.y, d1.x);
		auto r2 = atan2(d2.y, d2.x);
		auto ans = (r2 - r1) + 2 * M_PI;
		while (ans > 2 * M_PI) {
			ans -= 2 * M_PI;
		}
		if (ans > M_PI) {
			ans = 2 * M_PI - ans;
		}
		as[h[i].id] = ans/(2*M_PI);
	}
	cout << fixed << setprecision(10);
	for (auto p : as) {
		cout << p << endl;
	}
	return 0;
}


Measured memory_bytes: 4224