Language: C++

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <chrono>
using namespace std;

static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;

#define EPS (1e-10)
#define equals(a,b) (fabs((a) - (b)) < EPS)

class Point {
public:
	int id;
	double x, y;

	Point (int id = -1, double x = 0, double y = 0):id(id),x(x),y(y){}

	Point operator+(Point p) { return Point(id, x + p.x, y + p.y); }
	Point operator-(Point p) { return Point(id, x - p.x, y - p.y); }
	Point operator*(double a) { return Point(id, x * a, y*a); }
	Point operator/(double a) { return Point(id, x/a, y/a); }

	double abs() { return sqrt(norm()); }
	double norm() { return x * x + y * y; }

	bool operator<(const Point &p)const {
		return x != p.x ? x<p.x : y<p.y;
	}

	bool operator==(const Point &p)const {
		return fabs(x - p.x) < EPS && fabs(y - p.y) < EPS;
	}
};

typedef Point Vector;
typedef vector<Point> Polygon;

double dot(Vector a, Vector b) { return a.x*b.x + a.y*b.y; }
double cross(Vector a, Vector b) { return a.x * b.y - a.y * b.x; }

int ccw(Point p0, Point p1, Point p2) {
	Vector a = p1 - p0;
	Vector b = p2 - p0;
	if (cross(a, b) > EPS)return COUNTER_CLOCKWISE;
	if (cross(a, b) < -EPS)return CLOCKWISE;
	if (dot(a, b) < -EPS)return ONLINE_BACK;
	if (a.norm() < b.norm())return ONLINE_FRONT;

	return ON_SEGMENT;
}

#define PI 3.1415926535

double angle(Vector a, Vector b) {
	double lenA = a.abs();
	double lenB = b.abs();

	double cos_sita = dot(a, b) / (lenA * lenB);

	double sita = acos(cos_sita);

	sita = sita * 180 / PI;

	return sita;
}

Polygon andrewScan(Polygon s) {
	Polygon u, l;
	if (s.size() < 3)return s;
	sort(s.begin(), s.end());
	u.push_back(s[0]);
	u.push_back(s[1]);
	l.push_back(s[s.size() - 1]);
	l.push_back(s[s.size() - 2]);

	for (int i = 2; i < s.size(); i++) {
		for (int n = u.size(); n >= 2 && ccw(u[n - 2], u[n - 1], s[i]) != CLOCKWISE; n--) {
			u.pop_back();
		}
		u.push_back(s[i]);
	}

	for (int i = s.size() - 3; i >= 0; i--) {
		for (int n = l.size(); n >= 2 && ccw(l[n - 2], l[n - 1], s[i]) != CLOCKWISE; n--) {
			l.pop_back();
		}
		l.push_back(s[i]);
	}

	reverse(l.begin(), l.end());
	for (int i = u.size() - 2; i >= 1; i--)l.push_back(u[i]);

	return l;
}

int main() {
	int N; cin >> N;

	Polygon Ps(N);
	for (int i = 0; i < N; i++) {
		cin >> Ps[i].x >> Ps[i].y;
		Ps[i].id = i;
	}

	Polygon andrew = andrewScan(Ps);

	vector<double>ans(N);

	int size = andrew.size();
	for (int i = 0; i < andrew.size(); i++) {
		Vector a, b;
		a.x = andrew[(i + 1) % size].x - andrew[i].x;
		a.y = andrew[(i + 1) % size].y - andrew[i].y;

		b.x = andrew[(i - 1 + size) % size].x - andrew[i].x;
		b.y = andrew[(i - 1 + size) % size].y - andrew[i].y;

		ans[andrew[i].id] = (180 - angle(a, b)) / 360.;
	}

	for (int i = 0; i < N; i++)cout << ans[i] << endl;

	return 0;
}

Compiler output:
a.cc: In member function 'double Point::abs()':
a.cc:29:31: error: 'sqrt' was not declared in this scope
   29 |         double abs() { return sqrt(norm()); }
      |                               ^~~~
a.cc: In member function 'bool Point::operator==(const Point&) const':
a.cc:37:24: error: 'fabs' was not declared in this scope; did you mean 'abs'?
   37 |                 return fabs(x - p.x) < EPS && fabs(y - p.y) < EPS;
      |                        ^~~~
      |                        abs
a.cc: In function 'double angle(Vector, Vector)':
a.cc:66:23: error: 'acos' was not declared in this scope
   66 |         double sita = acos(cos_sita);
      |                       ^~~~