//경로 출력 함수
void printPath(int start, const int P[][4096]){
int A=4095-POW_2(start-1), next=P[start][A];
for(int i=0;i<12;i++){
printf(" %s ", cityName[next]);
if(i+1==start)
A-=POW_2(P[start][A]-1);
else
A-=POW_2(P[next][A]-1);
next=P[next][A];
printf("->");
}
}
/*
* FUNCTION
* Name: polarization
* Description: Polarization P through the CP formula
*
*/
double polarization ( void* params, double oc )
{
struct f_params* pars = (struct f_params*) params ;
double Omega, omega_1, b ;
Omega = pars->Omega ;
omega_1 = pars->omega_1 ;
b = pars->beta ;
double P, num, den, add1, add2, Jplus, Jminus ;
Jplus = J(omega_1 + Omega, oc) ;
Jminus = J(omega_1 - Omega, oc) ;
add1 = POW_2(omega_1 - Omega)*Jplus ;
add2 = POW_2(omega_1 + Omega)*Jminus ;
num = add1 + add2 ;
den = add1/(tanh((omega_1+Omega)*b/2)) +
add2/(tanh((omega_1-Omega)*b/2)) ;
P = num/den ;
return (P);
} /* ----- end of function polarization ----- */
//비트 검사 함수
int checkBit(int bitS){
int i=CITYCOUNT-1, bit=bitS, sum=0;
//들어가있는 비트를 검사하여 부분집합의 개수 파악하여 리턴
while(i>=0){
b[i]=bit>>i;
sum+=b[i];
if(b[i]==1)
bit-=POW_2(i);
--i;
}
return sum;
}
double K_E_n(const gsl_matrix* alle, double n, double sigma) {
double m_1 = MSUN_TO_MJUP(MGET(alle, 0, MASS));
double m_2 = MGET(alle, 1, MASS);
double m_3 = MGET(alle, 2, MASS);
double m_12 = m_1 + m_2;
double a_i = MGET(alle, 1, SMA);
double a_o = MGET(alle, 2, SMA);
double e_i = MGET(alle, 1, ECC);
double e_o = MGET(alle, 2, ECC);
double xi = acosh(1/e_o) * sqrt(1-e_o*e_o);
double E_22 = 4.*SQRT_TWOPI/3. * pow(1-e_o*e_o, 0.75)/(e_o * e_o) * pow(sigma, 5./2.) * exp(-sigma*xi);
double I_22 = 9./4. * m_3 / m_12 * POW_3(a_i/a_o) * E_22;
double e_i_ind = sqrt(e_i * e_i + I_22 * I_22);
double eps_o = sqrt(1-e_i*e_i);
double e_eq;
if (e_i < 0.) {
e_eq = (5./4.) * e_o * m_3 * (m_1 - m_2) * SQR(a_i/a_o) * sigma /
(eps_o * fabs(m_1*m_2 - m_12*m_3 * (a_i/a_o) * eps_o * sigma));
} else {
double A = 0.75 * (m_3 / m_12) * POW_3(a_i/a_o) / POW_3(eps_o);
double B = 15./64. * (m_3 / m_12) * (m_1-m_2)/m_12 * POW_4(a_i/a_o) / POW_5(eps_o);
double C = 3./4. * (m_1 * m_2 / SQR(m_12)) * SQR(a_i/a_o) / POW_4(eps_o);
double D = 15./64. * (m_1 * m_2 / SQR(m_12)) * (m_1-m_2)/m_12 * POW_3(a_i/a_o) * (1+4*e_o * e_o)/(e_o * POW_6(eps_o));
double a[9] = {-B*B, 2*A*B, B*B + C*C - A*A,
-2*(A*B + 4*C*D), A*A + 3*C*C + 16*D*D,
-18*C*D, 9./4. * C*C + 24*D*D, -9*C*D, 9*D*D};
gsl_poly_complex_workspace * w = gsl_poly_complex_workspace_alloc(9);
double z[16];
gsl_poly_complex_solve(a, 9, w, z);
for (int i = 0; i < 16; i+=2)
if (z[i] > 0 && z[i] < 1) {
e_eq = z[i];
break;
}
gsl_poly_complex_workspace_free(w);
}
double alpha = fabs(1-e_i/e_eq);
double e_i_oct = (alpha < 1 ? (1+alpha) * e_eq : e_i + 2*e_eq);
e_i = MAX(e_i_ind, e_i_oct);
double s = -3*e_i + 13./8. * POW_3(e_i) + 5./192. * POW_5(e_i) - 227./3072. * POW_7(e_i);
double F = E_22/(TWOPI * n);
double M_i = m_3 / (m_12 + m_3);
double M_o = (m_1 * m_2 / POW_2(m_12)) * pow(m_12 / (m_12+m_3), 2./3.);
double A_n = -9./2. * s * F * (M_i + M_o * pow(n, 2./3.));
double E_n = 0.5 * POW_2(sigma-n) - 2.*A_n;
/*
PRINTNUM(A_n);
PRINTNUM(E_n);
PRINTNUM(I_22);
PRINTNUM(n);
PRINTNUM(sigma);
PRINTNUM(s);
PRINTNUM(F);
PRINTNUM(e_i);
PRINTNUM(e_i_oct);
PRINTNUM(e_i_ind);
PRINTNUM(e_eq);
*/
return E_n;
}
float
Engine::distanceTo(float x, float y) const
{
return std::sqrt(POW_2(ABS(x - _x)) + POW_2(ABS(y - _y)));
}
