#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <cmath>
using namespace std;

class Point {
public:
	long double px, py;
	Point() : px(0), py(0) {};
	Point(long double px_, long double py_) : px(px_), py(py_) {};
	bool operator==(const Point& p) const { return px == p.px && py == p.py; }
	bool operator!=(const Point& p) const { return px != p.px || py != p.py; }
	bool operator<(const Point& p) const { return px < p.px ? true : (px == p.px && py < p.py); }
	bool operator>(const Point& p) const { return px > p.px ? true : (px == p.px && py > p.py); }
	bool operator<=(const Point& p) const { return !(Point(px, py) > p); }
	bool operator>=(const Point& p) const { return !(Point(px, py) < p); }
	Point operator+(const Point& p) const { return Point(px + p.px, py + p.py); }
	Point operator-(const Point& p) const { return Point(px - p.px, py - p.py); }
	Point operator/(long double d) const { return Point(px / d, py / d); }
	friend Point operator*(const Point p, long double d) { return Point(p.px * d, p.py * d); }
	friend Point operator*(long double d, const Point& p) { return p * d; }
	Point& operator+=(const Point& p1) { px += p1.px, py += p1.py; return *this; }
	Point& operator-=(const Point& p1) { px -= p1.px, py -= p1.py; return *this; }
	Point& operator*=(long double d) { px *= d, py *= d; return *this; }
	Point& operator/=(long double d) { px /= d, py /= d; return *this; }
};
long double norm(const Point& a) { return a.px * a.px + a.py * a.py; }
long double dot(const Point& a, const Point& b) { return a.px * b.px + a.py * b.py; }
long double crs(const Point& a, const Point& b) { return a.px * b.py - a.py * b.px; }
int ccw(const Point& p0, const Point& p1, const Point& p2) {
	Point a = p1 - p0, b = p2 - p0;
	if (crs(a, b) > 1e-10) return 1;
	if (crs(a, b) < -1e-10) return -1;
	if (dot(a, b) < -1e-10) return 2;
	if (norm(a) < norm(b)) return -2;
	return 0;
}
vector<Point> convex_hull(std::vector<Point> v) {
	if (v.size() < 3) return v;
	struct sorter {
		bool operator()(const Point& p1, const Point& p2) const {
			if (fabs(p1.px - p2.px) < 1e-9) return p1.py < p2.py;
			return p1.px < p2.px;
		}
	};
	sort(v.begin(), v.end(), sorter());
	vector<Point> u = { v[0], v[1] }, l = { v[v.size() - 1], v[v.size() - 2] };
	for (int i = 2; i < v.size(); i++) {
		for (int n = u.size(); n >= 2 && ccw(u[n - 2], u[n - 1], v[i]) >= 0; n--) u.pop_back();
		u.push_back(v[i]);
	}
	for (int i = v.size() - 3; i >= 0; i--) {
		for (int n = l.size(); n >= 2 && ccw(l[n - 2], l[n - 1], v[i]) >= 0; n--) l.pop_back();
		l.push_back(v[i]);
	}
	reverse(l.begin(), l.end());
	for (int i = u.size() - 2; i >= 1; i--) l.push_back(u[i]);
	return l;
}

int n; long double x[109], y[109], ans[109]; vector<Point>P; vector<long double>I;

long double arcs(long double I, int ty) {
	long double X = 1.0L, Y = I, Z = sqrtl(X*X + Y*Y);
	I = 1.0L*Y / Z;
	I = asin(I); I *= 0.5L / 3.14159265358979L;
	if (ty == 1) {
		if (I >= 0.0L) return I;
		return 1.0L + I;
	}
	return 0.5L + I;
}

int main() {
	cin >> n;
	P.resize(n, Point{ 0.0L,0.0L });
	for (int i = 0; i < n; i++) {
		cin >> P[i].px >> P[i].py;
		x[i] = P[i].px; y[i] = P[i].py;
	}
	vector<Point>Q = convex_hull(P);
	for (int i = 0; i < Q.size(); i++) {
		if (fabs(Q[i].px - Q[(i + 1) % Q.size()].px) < 1e-9) {
			if (Q[i].py < Q[(i + 1) % Q.size()].py) I.push_back(0.25L);
			else I.push_back(0.75L);
			continue;
		}
		long double T = (Q[(i + 1) % Q.size()].py - Q[i].py) / (Q[(i + 1) % Q.size()].px - Q[i].px);
		int TT = 0;
		if (Q[i].px < Q[(i + 1) % Q.size()].px) TT = 1;
		I.push_back(arcs(T, TT));
	}
	for (int i = 0; i < Q.size(); i++) {
		long double Y = I[i] - I[(i - 1 + (int)I.size()) % I.size()]; if (Y < -1e-14)Y += 1.0L;
		for (int j = 0; j < n; j++) {
			if (fabs(Q[i].px - x[j]) < 1e-6 && fabs(Q[i].py - y[j]) < 1e-6) {
				ans[j] = Y;
			}
		}
	}
	for (int i = 0; i < n; i++) {
		printf("%.12Lf\n", ans[i]);
	}
	return 0;
}

Measured memory_bytes: 256