#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define mp make_pair
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
#define xx real()
#define yy imag()

#define REP(i, a, b) for(int i = (a); i < (int)(b); i++)
#define REPN(i, a, b) for(int i = (a); i <= (int)(b); i++)
#define FA(it, x) for(__typeof((x).begin()) it = (x).begin(); it != (x).end(); it++)
#define SZ(x) (int)(x).size()
#define BE(x) (x).begin(), (x).end()
#define SORT(x) sort(BE(x))
#define _1 first
#define _2 second

#define x1 gray_cat_x1
#define y1 gray_cat_y1

template<class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

#define file "I1"

const double EPS = 1e-9;
const double PI = acos(-1.);
const int INF = 1e9;
const ll MOD = 1e9 + 7;

// OOP - based convex hull.
// Uses Graham algorithm.
// Complexity - O(n log n), where n - number of points in convex hull.
// Use: fill pts.n 9number of points), pts.pt (array of points).
// Call pts.build_convex_hull()
// Answer will be in array pts.pt_conv, number of points in convex hull - in n_conv.

const int MAXN = 1e3 + 5;

template<typename T> struct point {
	T x, y;
	int ind;
	
	point() { }
	
	point(T _x, T _y) {
		x = _x, y = _y;
	}
	
	bool operator == (const point<T> &b) {
		return (this->x == b.x) && (this->y == b.y);
	}
	
	// First by y, then by x
	bool operator < (const point<T> &b) {
		return (this->y != b.y) ? (this->y < b.y) : (this->x < b.x);
	}
	
	static T dot (const point<T> &o, const point<T> &a, const point<T> &b) {
		return (a.x - o.x) * (b.x - o.x) + (a.y - o.y) * (b.y - o.y);
	}
	
	static T cross (const point<T> &o, const point<T> &a, const point<T> &b) {
		return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
	}
	
	static T dis2 (const point<T> &a, const point<T> &b) {
		return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
	}
};

template<typename T> struct point_sorter {
	// Special point for sorting by angle
	static point<T> pt0;

	// Comparator for sorting by angle 
	static bool cmp_by_angle(const point<T> &a, const point<T> &b) {
		T tmp = point<T>::cross(pt0, a, b);
		if (tmp){
			return tmp > (T)0;
		}
		return point<T>::dis2(pt0, a) < point<T>::dis2(pt0, b);
	}
};

// ATTENTION! 
// This is C++ feature - static variables are defined separately,
// while non-static are defined when declared.
template<typename T> point<T> point_sorter<T>::pt0;

template<typename T> struct point_set {
	// Points count
	int n;
	
	// Initial array of points
	point<T> pt[MAXN];
	
	// Arrays of points for convex hull
	point<T> pt1[MAXN], pt2[MAXN];
	
	// Number of points in convex hull
	int n_conv;
	
	// Array of points for convex hull
	point<T> pt_conv[MAXN];
	
	
	
	// Get index of minimal point 
	int get_minimal_point_index() {
		int min_index = 0;
		for (int i = 1; i < n; i++) {
			if (pt[i] < pt[min_index]) {
				min_index = i;
			}
		}
		return min_index;
	}
	
	// Sort by coordinates (first by y, then by x)
	void sort_by_coordinates() {
		sort(pt, pt + n);
	}
	
	// Sort by angle
	void sort_by_angle() {
		int min_index = get_minimal_point_index();
		swap(pt[0], pt[min_index]);
		point_sorter<T>::pt0 = pt[0];
		sort(pt + 1, pt + n, point_sorter<T>::cmp_by_angle);
	}
	
	// Conveh hull - Graham
	void build_convex_hull() {
		int i, top1, top2;
		sort_by_coordinates();
		if (pt[0] == pt[n - 1]){
			n_conv = 0;
			pt_conv[n_conv++] = pt[0];
			return;
		}
		pt1[0] = pt2[0] = pt[n - 1];
		pt1[1] = pt2[1] = pt[0];
		top1 = top2 = 2;
		for(i = 1; i < n; i++){
			T d = point<T>::cross(pt[0], pt[n - 1], pt[i]);
			if (i == n - 1 || d < (T)0){
			for(; top1 > 2 && point<T>::cross(pt1[top1 - 2], pt1[top1 - 1], pt[i]) <= (T)0; top1--);
				pt1[top1++] = pt[i];
			}
			if (i == n - 1 || d > (T)0){
				for(; top2 > 2 && point<T>::cross(pt2[top2 - 2], pt2[top2 - 1], pt[i]) >= (T)0; top2--);
				pt2[top2++] = pt[i];
			}
		}
		n_conv = 0;
		for(i = 1; i < top1; i++){
			pt_conv[n_conv++] = pt1[i];
		}
		for(i = top2 - 2; i > 1; i--){
			pt_conv[n_conv++] = pt2[i];
		}
	}
};

point_set<long long> pts;

double ans[MAXN];

void solve(){
	scanf("%d", &pts.n);
	REP(i, 0, pts.n) {
		scanf("%lld%lld", &pts.pt[i].x, &pts.pt[i].y);
		pts.pt[i].ind = i;
	}
	pts.build_convex_hull();
	
	/*REP(i, 0, pts.n_conv) {
		printf("%d %lld %lld\n", pts.pt_conv[i].ind, pts.pt_conv[i].x, pts.pt_conv[i].y);
	}*/
	
	if (pts.n_conv == 1) {
		ans[pts.pt_conv[0].ind] = 1.0;
	} else if (pts.n_conv == 2) {
		ans[pts.pt_conv[0].ind] = 0.5;
		ans[pts.pt_conv[1].ind] = 0.5;
	} else {
		pts.pt_conv[pts.n_conv] = pts.pt_conv[0];
		pts.pt_conv[pts.n_conv + 1] = pts.pt_conv[1];
		REPN(i, 1, pts.n_conv) {
			ll dot_p = point<ll>::dot(pts.pt_conv[i], pts.pt_conv[i - 1], pts.pt_conv[i + 1]);
			ll dis2_1 = point<ll>::dis2(pts.pt_conv[i], pts.pt_conv[i - 1]);
			ll dis2_2 = point<ll>::dis2(pts.pt_conv[i], pts.pt_conv[i + 1]);
			double cos_ang = dot_p / (sqrt(dis2_1 + 0.0) * sqrt(dis2_2 + 0.0));
			double ang = acos(cos_ang);
			ans[pts.pt_conv[i].ind] = (PI - ang) / (2. * PI);
		}
	}
	
	REP(i, 0, pts.n) {
		printf("%.12lf\n", ans[i]);
	}
}

int main(){

    //freopen(file".in", "r", stdin); freopen(file".out", "w", stdout);
    int t = 1;
    //cin >> t;
    while(t--){
        solve();    
    }
}


Measured memory_bytes: 256