import std.stdio, std.conv, std.string, std.array, std.range, std.algorithm, std.container;
import std.math, std.random, std.bigint, std.datetime, std.format;
void main(string[] args){ if(args.length > 1) if(args[1] == "-debug") DEBUG = 1; solve(); } bool DEBUG = 0; 
void log(A ...)(lazy A a){ if(DEBUG) print(a); }
void print(){ writeln(""); } void print(T)(T t){ writeln(t); } void print(T, A ...)(T t, A a){ write(t, " "), print(a); }
string unsplit(T)(T xs){ return xs.array.to!(string[]).join(" "); }
string scan(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
T scan(T)(){ return scan.to!T; } T[] scan(T)(int n){ return n.iota.map!(i => scan!T()).array; }
T lowerTo(T)(ref T x, T y){ if(x > y) x = y; return x; } T raiseTo(T)(ref T x, T y){ if(x < y) x = y; return x; }

// ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- //

void solve(){
    int n = scan!int;
    Vector[] ps;
    foreach(_; 0 .. n) ps ~= Vector(scan!long, scan!long);

    Edge[] edges;
    foreach(i1, p1; ps) foreach(i2, p2; ps){
        if(p1 == p2) continue;
        Edge ed = Edge(i1.to!int, i2.to!int, p2 - p1);
        bool f = 1;
        foreach(p3; ps){
            if(p3 == p1 || p3 == p2) continue;
            Vector v = p3 - p1;
            if(v.isLeftTo(ed.v) || v.arg == ed.v.arg && v.square < ed.v.square) continue;
            f = 0;
            break;
        }
        if(f) edges ~= ed;
    }

    edges.sort!"a.v.arg.follows(b.v.arg)"();
    if(DEBUG) foreach(edge; edges) edge.writeln;

    edges ~= edges[0];
    real[] ans = new real[](n);
    foreach(i; 0 .. n) ans[i] = 0.0;
    foreach(i; 0 .. edges.length - 1){
        Edge ed1 = edges[i], ed2 = edges[i + 1];
        int id = ed1.id2;
        Argument arg = ed2.v.arg - ed1.v.arg;
        real angle = arg.angle;
        ans[id] = (angle / PI / 2.0);
    }

    foreach(an; ans) writefln("%3.10f", an);

    if(DEBUG){
        log(Argument(1, 0).angle, 0);
        log((Argument(1, 1) - Argument(17320508, 10000000)).angle, PI / 12);
        log(Argument(17320508, 10000000).angle, PI / 6);
        log(Argument(1, 1).angle, PI / 4);
        log(Argument(0, 1).angle, PI / 2);
        log(Argument(-1, 1).angle, PI * 3 / 4);
        log(Argument(-17320508, 10000000).angle, PI * 5 / 6);
        log(Argument(-1, 0).angle, PI);
        log(Argument(-17320508, -10000000).angle, PI * 7 / 6);
        log(Argument(0, -1).angle, PI * 3 / 2);
        log(Argument(17320508, -10000000).angle, PI * 11 / 6);
    }
}

struct Edge{
    int id1, id2;
    Vector v;
}




import std.conv, std.math;
struct Vector{
    long x, y;
    Argument arg;
    long square;
    real length;
    this(long x, long y){
        this.x = x, this.y = y;
        if(x != 0 || y != 0) arg = Argument(x, y);
        square = x * x + y * y;
        length = square.to!real.sqrt;
    }
    bool opEquals(Vector v){
        return x == v.x && y == v.y;
    }
	Vector opUnary(string s)(){
		if(s == "+") return Vector(x, y);
		if(s == "-") return Vector(-x, -y);
		assert(0, "Operator unary " ~ s ~ " not implemented");
	}
	Vector opBinary(string s)(Vector v){
		if(s == "+") return Vector(x + v.x, y + v.y);
		if(s == "-") return Vector(x - v.x, y - v.y);
		assert(0, "Operator " ~ s ~ " not implemented");
	}
    Vector opBinary(string s)(long k){
        if(s == "*") return Vector(x * k, y * k);
		assert(0, "Operator " ~ s ~ " not implemented");
    }
    Vector opBinaryRight(string s)(long k){
        if(s == "*") return Vector(k * x, k * y);
		assert(0, "Operator " ~ s ~ " not implemented");
    }

    int quadrant(){ return arg.quadrant; }
    bool isLeftTo(Vector v){ return arg.isLeftTo(v.arg); }
    bool follows(Vector v){ return arg.follows(v.arg); }
    string toString(){ return "(" ~ x.to!string ~ ", " ~ y.to!string ~ ")"; }
}
struct Argument{
    long x, y;
    this(long x, long y){
        assert(x != 0 || y != 0);
        this.x = x, this.y = y;
    }
    
    bool opEquals(Argument a){
        return quadrant == a.quadrant && y * a.x == x * a.y;
    }
	Argument opUnary(string s)(){
		if(s == "+") return Argument(x, y);
		if(s == "-") return Argument(-x, -y);
		assert(0, "Operator unary " ~ s ~ " not implemented");
	}
	Argument opBinary(string s)(Argument a){
		if(s == "+") return Argument(x * a.x - y * a.y, y * a.x + x * a.y);
		if(s == "-") return Argument(x * a.x + y * a.y, y * a.x - x * a.y);
		assert(0, "Operator " ~ s ~ " not implemented");
	}

    // 象限
    // (1, 0) ≦ this ＜ (0, 1) のとき 1　など
    int quadrant(){
        if(x > 0 && y >= 0) return 1;
        if(x <= 0 && y > 0) return 2;
        if(x < 0 && y <= 0) return 3;
        if(x >= 0 && y < 0) return 4;
        assert(0);
    }

    // a から見て this は左側である（aと平行は含まない）
    bool isLeftTo(Argument a){
        return y * a.x - x * a.y > 0;
    }

    // (1, 0) から反時計回りに見て this < a である
    bool follows(Argument a){
        int q = this.quadrant, aq = a.quadrant;
        if(q != aq) return q < aq;
        else return a.isLeftTo(this);
    }

    // 角度 (0 ≦ θ ＜ 2π)
    real angle(){
        real ans = atan2(y.to!real, x.to!real);
        if(ans < 0) return ans + PI + PI;
        else return ans;
    }

    string toString(){ return "(" ~ x.to!string ~ ", " ~ y.to!string ~ ")"; }
}