#include <cassert>
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <chrono>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#include <random>
#include <memory>
#include <utility>
#include <limits>
#include "limits.h"
 
#define rep(i, a, b) for (long long (i) = (a); i < (b); i++)
#define all(i) i.begin(), i.end()
#define debug(...) std::cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)

void debug_out(){std::cerr<<std::endl;}

template<typename Head,typename... Tail>
void debug_out(Head h,Tail... t){
  std::cerr<<" "<<h;
  debug_out(t...);
}
 
template <typename T1, typename T2>
std::ostream& operator<<(std::ostream& os, std::pair<T1, T2> pa) {
  return os << pa.first << " " << pa.second;
}
 
template <typename T>
std::ostream& operator<<(std::ostream& os, std::vector<T> vec) {
  for (int i = 0; i < vec.size(); i++)os << vec[i] << (i + 1 == vec.size() ? "" : " ");
  return os;
}
 
template<typename T1,typename T2>
inline bool chmax(T1& a,T2 b){return a<b && (a=b,true);}
 
template<typename T1,typename T2>
inline bool chmin(T1& a,T2 b){return a>b && (a=b,true);}
 
long long pow_mod(long long a, long long b, long long mod=-1) {
  if(b==0)return 1;
  if ((a == 0)||(mod!=-1&&(a+mod)%mod==0)) {
    return 0;
  }
  long long x = 1;
  while (b > 0) {
    if (b & 1) {
      x = (mod!=-1)?(x * a) % mod:x*a;
    }
    a = (mod!=-1)?(a * a) % mod:a*a;
    b >>= 1;
  }
  return x;
}

// const long long MOD = 998244353;
const long long MOD = 1e9 + 7;

using ll = long long;
using P=std::pair<long long,long long>;

using Point=std::complex<long double>;

const long double EPS=1e-10;
const long double PI=std::acos(-1.0l);

bool EQ(long double a,long double b){return std::abs(a-b)<EPS;}
bool EQP(Point a,Point b){return EQ(a.real(),b.real())&&EQ(a.imag(),b.imag());}

Point unitvec(Point a){return a/std::abs(a);}

//dot a・b = |a||b|cosθ
long double dot(Point a,Point b){
  return a.real()*b.real()+a.imag()*b.imag();
}

//cross a×b = |a||b|sinθ
long double cross(Point a,Point b){
  return a.real()*b.imag()-a.imag()*b.real();
}

//直線a,b上に点cがあるか
bool on_line(Point a,Point b,Point c){
  return EQ(cross(c-a,b-a),0.0l);
}

// [a,b]上に点cがあるか
bool on_segment(Point a,Point b,Point c){
  return std::abs(c-a)+std::abs(b-c)<std::abs(b-a)+EPS;
}

//どの2点も異なる点集合の凸包を求める
std::vector<std::pair<Point,long long>> convex(std::vector<std::pair<Point,long long>> set){
  using Pa=std::pair<Point,long long>;
  if(set.size()==1)return {set[0]};
  auto comp=[&](Pa a,Pa b){
    return (EQ(a.first.real(),b.first.real()))?(a.first.imag()>b.first.imag()):(a.first.real()<b.first.real());
  };

  std::sort(set.begin(),set.end(),comp);

  long long n=set.size();

  std::vector<Pa> lower,upper;

  lower.push_back(set[0]);
  long long lowernow=0;
  for(ll i=1;i<n;i++){
    while(lowernow>0){
      Point add=set[i].first-lower[lowernow].first;
      Point last=lower[lowernow-1].first-lower[lowernow].first;
      if(0<std::arg(last/add)&&std::arg(last/add)<PI-EPS){
        break;
      }else{
        lower.pop_back();
        lowernow--;
      }
    }
    if(i!=n-1)lower.push_back(set[i]);
    lowernow++;
  }

  upper.push_back(set[n-1]);
  long long uppernow=0;
  for(long long i=n-2;i>=0;i--){
    while(uppernow>0){
      Point add=set[i].first-upper[uppernow].first;
      Point last=upper[uppernow-1].first-upper[uppernow].first;
      if(0<std::arg(last/add)&&std::arg(last/add)<PI-EPS){
        break;
      }else{
        upper.pop_back();
        uppernow--;
      }
    }
    if(i!=0)upper.push_back(set[i]);
    uppernow++;
  }

  //for(auto low:lower)debug(low.first);
  //for(auto up:upper)debug(up.first);

  lower.reserve(lowernow+uppernow);
  std::copy(upper.begin(),upper.end(),std::back_inserter(lower));
  return lower;
}

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

  ll n;
  std::cin>>n;

  std::vector<long double> ans(n,0);

  std::vector<std::pair<Point,long long>> s;

  rep(i,0,n){
    long double x,y;
    std::cin>>x>>y;
    s.push_back({Point(x,y),i});
  }

  std::vector<std::pair<Point,long long>> conv=convex(s);

  ll m=conv.size();
  conv.reserve(2*m);

  std::copy(conv.begin(),conv.end(),std::back_inserter(conv));

  for(ll i=1;i<=m;i++){
    Point a=conv[i+1].first-conv[i].first;
    Point b=conv[i-1].first-conv[i].first;
    //debug(std::arg(b/a));
    ans[conv[i].second]=(PI-std::arg(b/a))/(2*PI);
  }

  std::cout<<std::setprecision(20)<<std::fixed;

  rep(i,0,n){
    std::cout<<ans[i]<<"\n";
  }

  return 0;
}

Measured memory_bytes: 256