#define ENABLE_DEBUG 0
// Kana's kitchen {{{
#include<bits/stdc++.h>
#define ALL(v) std::begin(v),std::end(v)
#define LOOP(k) for(i64 ngtkana_is_a_genius=0; ngtkana_is_a_genius<(i64)k; ngtkana_is_a_genius++)

using i32 = std::int_least32_t;
using i64 = std::int_least64_t;
using u32 = std::uint_least32_t;
using u64 = std::uint_least64_t;
using usize = std::size_t;

template <class T> using vec = std::vector<T>;
template <class T> using numr = std::numeric_limits<T>;

#ifdef NGTKANA
#include<debug.hpp>
#else
#define DEBUG(...)(void)0
#endif
/*}}}*/

template<std::size_t Idx, class Container, class Value = std::tuple_element_t<Idx, typename Container::value_type>>
auto project(Container const& container)
{
    std::vector<Value> ans(container.size());
    std::transform(ALL(container), ans.begin(), [](auto&& tuple){ return std::get<Idx>(tuple);});
    return ans;
}

template <class PlanarAdapter>
struct planar {
    using this_type = planar<PlanarAdapter>;
    using adapter_type = PlanarAdapter;
    using point_type = typename adapter_type::point_type;
    using coord_type = typename adapter_type::coord_type;
    using difference_type = std::pair<coord_type, coord_type>;

    static coord_type x(point_type const& p) { return adapter_type::x(p); }
    static coord_type y(point_type const& p) { return adapter_type::y(p); }

    static bool less(point_type const& p, point_type const& q) {
        return x(p)!=x(q) ? x(p)<x(q) : y(p)<y(q);
    }

    static difference_type sub(point_type const& p, point_type const& q) {
        return std::make_pair(x(q)-x(p), y(q)-y(p));
    }

    static coord_type sq_mag(difference_type const&d) {
        return d.first * d.first + d.second * d.second;
    }

    static coord_type dot(difference_type const& a, difference_type const& b) {
        return a.first * b.first + a.second * b.second;
    }

    static coord_type sq_dist(point_type const& p, point_type const& q) {
        return this_type::sq_mag(sub(p, q));
    }

    static coord_type det(difference_type const& a, difference_type const& b) {
        return a.first * b.second - a.second * b.first;
    }

    static coord_type det_of_broken_segment(point_type const& p, point_type const& q, point_type const& r) {
        return this_type::det(this_type::sub(q, p), this_type::sub(r, p));
    }

    static coord_type cosine_of_broken_segment(point_type const& p, point_type const& q, point_type const& r) {
        DEBUG( this_type::dot(this_type::sub(q, p), this_type::sub(r, q)) , this_type::sq_dist(p, q) , this_type::sq_dist(q, r) );
        return this_type::dot(this_type::sub(q, p), this_type::sub(r, q)) / std::sqrt( this_type::sq_dist(p, q) * this_type::sq_dist(q, r) );
    }

    static vec<point_type> lower_convex_hull(vec<point_type> const& v) {
        DEBUG(v);
        if (v.size() <= 1u) return v;
        vec<point_type> hull;
        for (auto&& p: v) {
            while (1u < hull.size()
                && this_type::det_of_broken_segment(hull.at(hull.size()-2), hull.at(hull.size()-1), p) <= coord_type{0})
            {
                hull.pop_back();
            }
            hull.push_back(p);
        }
        DEBUG(hull);
        return hull;
    }

    static vec<point_type> convex_hull(vec<point_type> v) {
        if (v.size() <= 1u) return v;
        // assert(std::is_sorted(v.begin(), v.end(), [](auto&&p, auto&&q) { less(p, q); }));

        auto lower = lower_convex_hull(v);
        std::reverse(v.begin(), v.end());
        auto hull = lower_convex_hull(v);

        lower.pop_back();
        hull.pop_back();
        hull.insert(hull.end(), lower.begin(), lower.end());
        return hull;
    }
};

struct planar_adapter {
    using coord_type = double;
    using point_type = std::tuple<coord_type, coord_type, usize>;

    static coord_type x(point_type const& p) { return std::get<0>(p); }
    static coord_type y(point_type const& p) { return std::get<1>(p); }
};


int main(){
    std::cin.tie(nullptr);
    std::ios::sync_with_stdio(false);
    std::cout << std::setprecision(15) << std::fixed;

    using planar_type = planar<planar_adapter>;

    using point_type = planar_type::point_type;

    usize n;
    std::cin >> n;
    vec<point_type> v(n);
    for (usize i=0; i<n; i++) {
        i64 x, y;
        std::cin >> x >> y;
        v.at(i) = std::make_tuple(x, y, i);
    }
    std::sort(ALL(v));

    auto hull = planar_type::convex_hull(v);
    for (usize i=0; i<2; i++) {
        hull.push_back(hull.at(i));
    }
    DEBUG(hull);

    double two_pi = 2 * std::acos(-1);

    vec<double> ans(n);
    for (usize i=0; i<hull.size()-2; i++) {
        point_type p = hull.at(i), q = hull.at(i+1), r = hull.at(i+2);
        double cost = planar_type::cosine_of_broken_segment(p, q, r);
        DEBUG(p, q, r, cost);
        ans.at(std::get<2>(q)) = std::acos(cost) / two_pi;
    }

    for (double x: ans) {
        std::cout << x << '\n';
    }
}



Measured memory_bytes: 640