data class Double2D(val x: Double, val y: Double) {
  operator fun plus(o: Double2D): Double2D {
    return Double2D(x + o.x, y + o.y)
  }
  operator fun minus(o: Double2D): Double2D {
    return Double2D(x - o.x, y - o.y)
  }
  operator fun times(o: Double): Double2D {
    return Double2D(x * o, y * o)
  }
  fun norm2(): Double {
    return x * x + y * y
  }
  fun norm(): Double {
    return Math.sqrt(x * x + y * y)
  }
}

fun cross(v1: Double2D, v2: Double2D): Double {
  return v1.x * v2.y - v1.y * v2.x
}

fun dot(v1: Double2D, v2: Double2D): Double {
  return v1.x * v2.x + v1.y * v2.y
}

fun ccw(p: Double2D, q: Double2D, r: Double2D): Int {
  val vq = q - p
  val vr = r - p
  if (cross(vq, vr) > 0)   return +1     // counter clockwise
  if (cross(vq, vr) < 0)   return -1     // clockwise
  if (dot(vq, vr) < 0)     return +2     // r-p-q on line
  if (vq.norm2() < vr.norm2()) return -2 // p-q-r on line
  return 0
}

fun compareDouble2D(p1: Double2D, p2: Double2D): Int {
  if (p1.x != p2.x) {
    return java.lang.Double.compare(p1.x, p2.x)
  }
  return java.lang.Double.compare(p1.y, p2.y)
}

fun convexHull(inputPs: List<Double2D>): List<Double2D> {
  val ps = inputPs.sortedWith(java.util.Comparator { p1, p2 -> compareDouble2D(p1, p2) })
  val n = ps.size
  val qs = mutableListOf<Double2D>()
  for (i in 0 until n) {
    while (qs.size >= 2 &&
        // Use "<= 0" here to exclude a point on an edge.
        ccw(qs[qs.size - 2], qs[qs.size - 1], ps[i]) == -1) {
      qs.removeAt(qs.size - 1)
    }
    qs.add(ps[i])
  }
  val lowerHullSize = qs.size
  for (i in n - 2 downTo 0) {
    while (qs.size >= lowerHullSize &&
        // Use "<= 0" here to exclude a point on an edge.
        ccw(qs[qs.size - 2], qs[qs.size - 1], ps[i]) == -1) {
      qs.removeAt(qs.size - 1)
    }
    qs.add(ps[i])
  }
  qs.removeAt(qs.size - 1)
  return qs
}

fun main(args: Array<String>) {
  val n = readLine()!!.toInt()
  // No List(n, {}) constructor for Kotlin 1.0.
  val ps = Array(n, {
    val (x, y) = readLine()!!.split(" ").map(String::toInt)
    Double2D(x.toDouble(), y.toDouble()) })
      .asList()
  val qs = convexHull(ps)
  val m = qs.size
  val args = mutableMapOf<Double2D, Double>()
  for (i in 0 until m) {
    val qm = qs[i]
    val qp = qs[(i + (m - 1)) % m]
    val qn = qs[(i + 1) % m]
    val v1 = qn - qm
    val v2 = qp - qm
    val cos_theta = dot(v1, v2) / v1.norm() / v2.norm()
    val theta = Math.acos(cos_theta)
    args[qs[i]] = Math.PI - theta
  }
  for (p in ps) {
    if (args.containsKey(p)) {
      val arg = args[p]!!
      println(String.format("%.9f", arg / (2.0 * Math.PI)))
    } else {
      println(0.0)
    }
  }
}