#include "iostream"
#include "climits"
#include "list"
#include "queue"
#include "stack"
#include "set"
#include "functional"
#include "algorithm"
#include "string"
#include "map"
#include "unordered_map"
#include "unordered_set"
#include "iomanip"
#include "cmath"
#include "random"
#include "bitset"
#include "cstdio"

using namespace std;

const long long int MOD = 1000000007;

long long int N, M, K, H, W, L, R;

const long double EPS = 1e-7;
const long double PI = 3.141592653589793238462643383279;

struct Coordinate {
	long double x;
	long double y;
	bool operator <(const Coordinate& c)const {
		if (y < c.y)return true;
		if (y > c.y)return false;
		if (x < c.x)return true;
		return false;
	}
	bool operator >(const Coordinate& c)const {
		if (y > c.y)return true;
		if (y < c.y)return false;
		if (x > c.x)return true;
		return false;
	}
	Coordinate operator +(const Coordinate& c)const {
		Coordinate box;
		box.x = x + c.x;
		box.y = y + c.y;
		if (abs(box.x) < EPS) {
			box.x = 0;
		}
		if (abs(box.y) < EPS) {
			box.y = 0;
		}
		return box;
	}
	Coordinate operator -(const Coordinate& c)const {
		Coordinate box;
		box.x = x - c.x;
		box.y = y - c.y;
		if (abs(box.x) < EPS) {
			box.x = 0;
		}
		if (abs(box.y) < EPS) {
			box.y = 0;
		}
		return box;
	}
	long double dot(Coordinate a) {
		return x*a.x + y*a.y;
	}
	long double det(Coordinate a) {
		return x*a.y - y*a.x;
	}
	long double dis() {
		return sqrt(x*x + y*y);
	}
};

struct Convex_hull {
	vector<Coordinate>node;
	vector<Coordinate>ret;
	bool line;
	Convex_hull(bool l) {
		line = l;
	}
	void Add_node(Coordinate n) {
		node.push_back(n);
	}
	vector<Coordinate>solve() {
		sort(node.begin(), node.end());
		int index = 0;
		int num = node.size();
		ret.resize(num * 2);
		for (int i = 0; i < num; i++) {
			if (line) {
				while (index > 1 && (ret[index - 1] - ret[index - 2]).det(node[i] - ret[index - 1]) < -EPS) {
					index--;
				}
			}
			else {
				while (index > 1 && (ret[index - 1] - ret[index - 2]).det(node[i] - ret[index - 1]) < EPS) {
					index--;
				}
			}
			ret[index++] = node[i];
		}
		int box = index;
		for (int i = num - 2; i >= 0; i--) {
			if (line) {
				while (index > box && (ret[index - 1] - ret[index - 2]).det(node[i] - ret[index - 1]) < -EPS) {
					index--;
				}
			}
			else {
				while (index > box && (ret[index - 1] - ret[index - 2]).det(node[i] - ret[index - 1]) < EPS) {
					index--;
				}
			}
			ret[index++] = node[i];
		}
		ret.resize(index - 1);
		return ret;
	}
};

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);

	cin >> N;
	cout << setprecision(20);
	vector<long double>ans(N);
	map<Coordinate, int>m;
	Convex_hull ch(false);
	for (int i = 0; i < N; i++) {
		Coordinate c;
		cin >> c.x >> c.y;
		m[c] = i;
		ch.Add_node(c);
	}
	auto node = ch.solve();
	int num = node.size();
	for (int i = 1; i <= num; i++) {
		long double theta = (node[(i - 1) % num] - node[i%num]).dot(node[(i + 1) % num] - node[i%num]) / (node[(i - 1) % num] - node[i%num]).dis() / (node[(i + 1) % num] - node[i%num]).dis();
		if (abs(1 - theta) < EPS) {
			theta = 1;
		}
		theta = acos(theta);
		if (abs(theta) < EPS) {
			theta = 0;
		}
		theta = PI - theta;
		ans[m[node[i%num]]] = theta / PI / 2;
	}
	for (auto i : ans) {
		if (abs(i) < EPS) {
			cout << 0 << endl;
		}
		else {
			cout << i << endl;
		}
	}
	return 0;
}


Measured memory_bytes: 256