Language: C++

#include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
const int INF=1e9,MOD=1e9+7,ohara=1e6+10;
const ll LINF=1e18;
using namespace std;

#define rep(i,n) for(int (i)=0;(i)<(int)(n);(i)++)
#define rrep(i,a,b) for(int i=(a);i<(b);i++)
#define rrrep(i,a,b) for(int i=(a);i>=(b);i--)
#define all(v) (v).begin(), (v).end()
#define Size(n) (n).size()
#define Cout(x) cout<<(x)<<endl
#define Cerr(x) cerr<<(x)<<endl
#define fi first
#define se second

ll n,cnt,a,b,c,d,tmp,tmpp,m,h,w,x[ohara],y[ohara],sum,pos;
ld doua;
int dy[]={1,0,-1,0};
int dx[]={0,1,0,-1};
//int dy[]={-1,0,1,-1,1,-1,0,1};
//int dx[]={-1,-1,-1,0,0,1,1,1};
string alph("abcdefghijklmnopqrstuvwxyz"),s;
bool fl;
struct edge{int to,cost;};
pair<ll,ll> ps[ohara];
double pi=acosl(-1.0);
map<pair<ll,ll>,double>ans;
map<pair<ll,ll>,ll> vi;

//-------------------------↓↓↓↓↓↓------------------------

//凸法////////////////////////////////////////////////////////////////////
typedef complex<ll> P;
namespace std {
  bool operator < (const P& a, const P& b) {
    return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
  }
}
double cross(const P& a, const P& b) {
  return imag(conj(a)*b);
}
double dot(const P& a, const P& b) {
  return real(conj(a)*b);
}
 
struct L : public vector<P> {
  L(const P &a, const P &b) {
    push_back(a); push_back(b);
  }
};
 
typedef vector<P> G;
 
struct C {
  P p; double r;
  C(const P &p, double r) : p(p), r(r) { }
};
 
int ccw(P a, P b, P c) {
  b -= a; c -= a;
  if (cross(b, c) > 0)   return +1;       // counter clockwise
  if (cross(b, c) < 0)   return -1;       // clockwise
  if (dot(b, c) < 0)     return +2;       // c--a--b on line
  if (norm(b) < norm(c)) return -2;       // a--b--c on line
  return 0;
}
 
typedef P point;
 
 
 
vector<point> convex_hull(vector<point> ps) {
  int n = ps.size(), k = 0;
  sort(ps.begin(), ps.end());
  vector<point> ch(2*n);
  for (int i = 0; i < n; ch[k++] = ps[i++]) // lower-hull
    while (k >= 2 && ccw(ch[k-2], ch[k-1], ps[i]) <= 0) --k;
  for (int i = n-2, t = k+1; i >= 0; ch[k++] = ps[i--]) // upper-hull
    while (k >= t && ccw(ch[k-2], ch[k-1], ps[i]) <= 0) --k;
  ch.resize(k-1);
  return ch;
}
 
///////////////////////////////////////////////////////////////////////////

int quadrant(ll tarx,ll tary,ll basex,ll basey){
  if(basex>=tarx&&basey>=tary)return 3;
  else if(basex>=tarx&&basey<=tary)return 2;
  else if(basex<=tarx&&basey<=tary)return 1;
  else return 4;
}

int main(void){
       cin.tie(0);
    ios::sync_with_stdio(false);

    cin>>n;
    if(n==2){
      printf("0.5\n0.5\n");
      return 0;
    }
    vector<P> pt(n);
    rep(i,n){
        cin>>x[i]>>y[i];//点の座標を受け取る
        pt[i]=P(x[i],y[i]);
    }
    vector<P> ch=convex_hull(pt);
    //ch.real()でx座標,ch.imag()でy座標
    rep(i,Size(ch)){
      ll vec1x,vec1y;
      ll vec2x,vec2y;
      ll x1,x2,y1,y2;
      if(i==0){
        x1=ch[Size(ch)-1].real();
        y1=ch[Size(ch)-1].imag();
      }
      else{
        x1=ch[i-1].real();
        y1=ch[i-1].imag();
      }
      if(i==Size(ch)-1){
        x2=ch[0].real();
        y2=ch[0].imag();
      }
      else{
        x2=ch[i+1].real();
        y2=ch[i+1].imag();
      }

      ///////////////2つのベクトルがなす角
      vec1x=ch[i].real()-x1;
      vec1y=ch[i].imag()-y1;
      vec2x=x2-ch[i].real();
      vec2y=y2-ch[i].imag();

      double length_A=pow((vec1x*vec1x)+(vec1y*vec1y),0.5);
      double length_B=pow((vec2x*vec2x)+(vec2y*vec2y),0.5);

      double cos_sita=(vec1x*vec2x+vec1y*vec2y)/(length_A*length_B);

      if(-1.0>cos_sita||cos_sita>1.0)continue;

      double sita=acos(cos_sita);

      //////////////////

      if(sita/(2.0*pi)==nan)continue;
      if(sita<180.0&&sita!=0.0){
      ans[{ch[i].real(),ch[i].imag()}]=sita/(2.0*pi);
      vi[{ch[i].real(),ch[i].imag()}]=1;
      }
    }
    rep(i,n){
      if(vi[{x[i],y[i]}]==0)printf("0.0000000000000000000000000000000\n");
      else printf("%.17f\n",ans[{x[i],y[i]}]);
    }
    return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:149:23: error: invalid operands of types 'double' and 'double(const char*) noexcept' to binary 'operator=='
  149 |       if(sita/(2.0*pi)==nan)continue;
      |          ~~~~~~~~~~~~~^~~~~
      |              |          |
      |              double     double(const char*) noexcept