static long double complex
clog_for_large_values(long double complex z)
{
long double x, y;
long double ax, ay, t;
x = creall(z);
y = cimagl(z);
ax = fabsl(x);
ay = fabsl(y);
if (ax < ay) {
t = ax;
ax = ay;
ay = t;
}
if (ax > HALF_MAX)
return (CMPLXL(logl(hypotl(x / m_e, y / m_e)) + 1,
atan2l(y, x)));
if (ax > QUARTER_SQRT_MAX || ay < SQRT_MIN)
return (CMPLXL(logl(hypotl(x, y)), atan2l(y, x)));
return (CMPLXL(logl(ax * ax + ay * ay) / 2, atan2l(y, x)));
}
long double complex
cacosl(long double complex z)
{
long double x, y, ax, ay, rx, ry, B, sqrt_A2mx2, new_x;
int sx, sy;
int B_is_usable;
long double complex w;
x = creall(z);
y = cimagl(z);
sx = signbit(x);
sy = signbit(y);
ax = fabsl(x);
ay = fabsl(y);
if (isnan(x) || isnan(y)) {
if (isinf(x))
return (CMPLXL(y + y, -INFINITY));
if (isinf(y))
return (CMPLXL(x + x, -y));
if (x == 0)
return (CMPLXL(pio2_hi + pio2_lo, y + y));
return (CMPLXL(nan_mix(x, y), nan_mix(x, y)));
}
if (ax > RECIP_EPSILON || ay > RECIP_EPSILON) {
w = clog_for_large_values(z);
rx = fabsl(cimagl(w));
ry = creall(w) + m_ln2;
if (sy == 0)
ry = -ry;
return (CMPLXL(rx, ry));
}
if (x == 1 && y == 0)
return (CMPLXL(0, -y));
raise_inexact();
if (ax < SQRT_6_EPSILON / 4 && ay < SQRT_6_EPSILON / 4)
return (CMPLXL(pio2_hi - (x - pio2_lo), -y));
do_hard_work(ay, ax, &ry, &B_is_usable, &B, &sqrt_A2mx2, &new_x);
if (B_is_usable) {
if (sx == 0)
rx = acosl(B);
else
rx = acosl(-B);
} else {
if (sx == 0)
rx = atan2l(sqrt_A2mx2, new_x);
else
rx = atan2l(sqrt_A2mx2, -new_x);
}
if (sy == 0)
ry = -ry;
return (CMPLXL(rx, ry));
}
// not correct
long double angleBetweenAtan2(Vector2d V1, Vector2d V2)
{
long double result;
Vector2d V1n = V1.getNormalized();
Vector2d V2n = V2.getNormalized();
long double a2 = atan2l(V2n.y, V2n.x);
long double a1 = atan2l(V1n.y, V1n.x);
result = a2 - a1;
if(result < 0)
result += 2.*M_PI;
return result;
}
long double complex
catanhl(long double complex z)
{
long double x, y, ax, ay, rx, ry;
x = creall(z);
y = cimagl(z);
ax = fabsl(x);
ay = fabsl(y);
if (y == 0 && ax <= 1)
return (CMPLXL(atanhl(x), y));
if (x == 0)
return (CMPLXL(x, atanl(y)));
if (isnan(x) || isnan(y)) {
if (isinf(x))
return (CMPLXL(copysignl(0, x), y + y));
if (isinf(y))
return (CMPLXL(copysignl(0, x),
copysignl(pio2_hi + pio2_lo, y)));
return (CMPLXL(nan_mix(x, y), nan_mix(x, y)));
}
if (ax > RECIP_EPSILON || ay > RECIP_EPSILON)
return (CMPLXL(real_part_reciprocal(x, y),
copysignl(pio2_hi + pio2_lo, y)));
if (ax < SQRT_3_EPSILON / 2 && ay < SQRT_3_EPSILON / 2) {
raise_inexact();
return (z);
}
if (ax == 1 && ay < LDBL_EPSILON)
rx = (m_ln2 - logl(ay)) / 2;
else
rx = log1pl(4 * ax / sum_squares(ax - 1, ay)) / 4;
if (ax == 1)
ry = atan2l(2, -ay) / 2;
else if (ay < LDBL_EPSILON)
ry = atan2l(2 * ay, (1 - ax) * (1 + ax)) / 2;
else
ry = atan2l(2 * ay, (1 - ax) * (1 + ax) - ay * ay) / 2;
return (CMPLXL(copysignl(rx, x), copysignl(ry, y)));
}
void
cm_float_atan2(unsigned argc, obj_t args)
{
obj_t recvr = CAR(args);
m_float_new(consts.cl._float, atan2l(FLOAT(recvr)->val, FLOAT(CAR(CDR(args)))->val));
}
long double
asinl(long double x) {
long double t, w;
#ifndef lint
volatile long double dummy;
#endif
w = fabsl(x);
if (isnanl(x))
return (x + x);
else if (w <= half) {
if (w < small) {
#ifndef lint
dummy = w + big;
/* inexact if w != 0 */
#endif
return (x);
} else
return (atanl(x / sqrtl(one - x * x)));
} else if (w < one) {
t = one - w;
w = t + t;
return (atanl(x / sqrtl(w - t * t)));
} else if (w == one)
return (atan2l(x, zero)); /* asin(+-1) = +- PI/2 */
else
return (zero / zero); /* |x| > 1: invalid */
}
void test_atan2()
{
static_assert((std::is_same<decltype(atan2((double)0, (double)0)), double>::value), "");
static_assert((std::is_same<decltype(atan2f(0,0)), float>::value), "");
static_assert((std::is_same<decltype(atan2l(0,0)), long double>::value), "");
assert(atan2(0,1) == 0);
}
long double complex
catanl(long double complex z)
{
long double complex w;
long double a, t, x, x2, y;
x = creall(z);
y = cimagl(z);
if ((x == 0.0L) && (y > 1.0L))
goto ovrf;
x2 = x * x;
a = 1.0L - x2 - (y * y);
if (a == 0.0L)
goto ovrf;
t = atan2l(2.0L * x, a) * 0.5L;
w = redupil(t);
t = y - 1.0L;
a = x2 + (t * t);
if (a == 0.0L)
goto ovrf;
t = y + 1.0L;
a = (x2 + (t * t)) / a;
w = w + (0.25L * logl(a)) * I;
return (w);
ovrf:
/*mtherr( "catanl", OVERFLOW );*/
w = LDBL_MAX + LDBL_MAX * I;
return (w);
}
int main(){
const long double PI = 3.1415926535897932384626433832795028841971693993751;
long n; scanf("%ld\n", &n);
std::vector<std::pair<long double, long> > proj(n);
for(long p = 0; p < n; p++){
long x, y; scanf("%ld %ld\n", &x, &y);
long double angle = atan2l(y, x);
if(angle < 0){angle += 2 * PI;}
proj[p] = std::pair<long double, long>(angle, p) ;
}
sort(proj.begin(), proj.end());
long double minDiff = 2 * PI - (proj[n - 1].first - proj[0].first);
std::pair<long, long> closest = std::pair<long, long>(proj[0].second, proj[n - 1].second);
for(int p = 1; p < n; p++){
long double diff = proj[p].first - proj[p - 1].first;
if(diff < minDiff){minDiff = diff; closest = std::pair<long, long>(proj[p - 1].second, proj[p].second);}
}
printf("%ld %ld\n", 1 + closest.first, 1 + closest.second);
return 0;
}
void entity::gravitate (struct entity object) { //calculates gravitational forces, and accelerates, between two entities
float theta = atan2l (object.y - y, object.x - x); //finds angle at which hab is from earth
float gravity = G * ( (object.mass * mass) / (distance (object.x, object.y) * distance (object.x, object.y) ) ); //finds total gravitational force between hab and earth, in the formula G (m1 * m2) / r^2
accX (theta, gravity);
accY (theta, gravity);
}
ldcomplex
clogl(ldcomplex z) {
ldcomplex ans;
long double x, y, t, ax, ay;
int n, ix, iy, hx, hy;
x = LD_RE(z);
y = LD_IM(z);
hx = HI_XWORD(x);
hy = HI_XWORD(y);
ix = hx & 0x7fffffff;
iy = hy & 0x7fffffff;
ay = fabsl(y);
ax = fabsl(x);
LD_IM(ans) = atan2l(y, x);
if (ix < iy || (ix == iy && ix < 0x7fff0000 && ax < ay)) {
/* swap x and y to force ax>=ay */
t = ax;
ax = ay;
ay = t;
n = ix, ix = iy;
iy = n;
}
n = (ix - iy) >> 16;
if (ix >= 0x7fff0000) { /* x or y is Inf or NaN */
if (isinfl(ax))
LD_RE(ans) = ax;
else if (isinfl(ay))
LD_RE(ans) = ay;
else
LD_RE(ans) = ax + ay;
} else if (ay == zero)
LD_RE(ans) = logl(ax);
else if (((0x3fffffff - ix) ^ (ix - 0x3ffe0000)) >= 0) {
/* 0.5 <= x < 2 */
if (ix >= 0x3fff0000) {
if (ax == one)
LD_RE(ans) = half * log1pl(ay * ay);
else if (n >= SIGP7)
LD_RE(ans) = logl(ax);
else
LD_RE(ans) = half * (log1pl(ay * ay + (ax -
one) * (ax + one)));
} else if (n >= SIGP7)
LD_RE(ans) = logl(ax);
else
LD_RE(ans) = __k_clog_rl(x, y, &t);
} else if (n >= HSIGP7)
LD_RE(ans) = logl(ax);
else if (ix < 0x5f3f0000 && iy >= 0x20bf0000)
/* 2**-8000 < y < x < 2**8000 */
LD_RE(ans) = half * logl(ax * ax + ay * ay);
else {
t = ay / ax;
LD_RE(ans) = logl(ax) + half * log1pl(t * t);
}
return (ans);
}
void test3l(__complex__ long double x, __complex__ long double y, int i)
{
if (ccosl(x) != ccosl(-x))
link_error();
if (ccosl(ctanl(x)) != ccosl(ctanl(-x)))
link_error();
if (ctanl(x-y) != -ctanl(y-x))
link_error();
if (ccosl(x/y) != ccosl(-x/y))
link_error();
if (ccosl(x/y) != ccosl(x/-y))
link_error();
if (ccosl(x/ctanl(y)) != ccosl(-x/ctanl(-y)))
link_error();
if (ccosl(x*y) != ccosl(-x*y))
link_error();
if (ccosl(x*y) != ccosl(x*-y))
link_error();
if (ccosl(ctanl(x)*y) != ccosl(ctanl(-x)*-y))
link_error();
if (ccosl(ctanl(x/y)) != ccosl(-ctanl(x/-y)))
link_error();
if (ccosl(i ? x : y) != ccosl(i ? -x : y))
link_error();
if (ccosl(i ? x : y) != ccosl(i ? x : -y))
link_error();
if (ccosl(i ? x : ctanl(y/x)) != ccosl(i ? -x : -ctanl(-y/x)))
link_error();
if (~x != -~-x)
link_error();
if (ccosl(~x) != ccosl(-~-x))
link_error();
if (ctanl(~(x-y)) != -ctanl(~(y-x)))
link_error();
if (ctanl(~(x/y)) != -ctanl(~(x/-y)))
link_error();
#ifdef HAVE_C99_RUNTIME
if (cargl(x) != atan2l(__imag__ x, __real__ x))
link_error ();
#endif
}
void MainWindow::collision(auto cba, auto cbb)
{
if (cba->distance_2(*cbb) > (cba->getRadius() + cbb->getRadius())*(cba->getRadius() + cbb->getRadius()))
return;
// niech cialo a porusza sie wzgledem ciala b, a cialo b bedzie nieruchome
long double deltaVx1, deltaVy1, deltaVx2, deltaVy2; // koncowe roznice szybkosci
long double deltaPosX = cba->getX() - cbb->getX();
long double deltaPosY = cba->getY() - cbb->getY();
long double collisionAngle = atan2l(deltaPosX,deltaPosY);
long double velocityAngle = atan2l(cba->getVx(),cba->getVy());
if (collisionAngle < 0) collisionAngle += 2.0*M_PI;
if (velocityAngle < 0) velocityAngle += 2.0*M_PI;
if (((deltaPosX < 0) xor (cba->getVx() < 0)) or ((deltaPosY < 0) xor (cba->getVy() < 0))) // jesli a zbliza sie do b
{
}
}
long double complex
clogl(long double complex z)
{
long double complex w;
long double p, rr;
rr = cabsl(z);
p = logl(rr);
rr = atan2l(cimagl(z), creall(z));
w = p + rr * I;
return w;
}
long double complex
clogl(long double complex z)
{
long double complex w;
long double p, rr;
/*rr = sqrt(z->r * z->r + z->i * z->i);*/
p = cabsl(z);
p = logl(p);
rr = atan2l(cimagl(z), creall(z));
w = p + rr * I;
return (w);
}
void entity::detectCollision (struct entity object) {
long double stepDistance = distance (object.x + object.Vx, object.y + object.Vy) + (Vx + Vy) - (radius + object.radius); //the distance the objects will be at the next move
if (stepDistance < 0) {
Vx = object.Vx;
Vy = object.Vy;
if (stepDistance < -0.01 ) {
long double angle = atan2l (object.y - y, object.x - x);
x -= cos (angle);
y -= sin (angle);
}
}
}
long double complex
casinhl(long double complex z)
{
long double x, y, ax, ay, rx, ry, B, sqrt_A2my2, new_y;
int B_is_usable;
long double complex w;
x = creall(z);
y = cimagl(z);
ax = fabsl(x);
ay = fabsl(y);
if (isnan(x) || isnan(y)) {
if (isinf(x))
return (CMPLXL(x, y + y));
if (isinf(y))
return (CMPLXL(y, x + x));
if (y == 0)
return (CMPLXL(x + x, y));
return (CMPLXL(nan_mix(x, y), nan_mix(x, y)));
}
if (ax > RECIP_EPSILON || ay > RECIP_EPSILON) {
if (signbit(x) == 0)
w = clog_for_large_values(z) + m_ln2;
else
w = clog_for_large_values(-z) + m_ln2;
return (CMPLXL(copysignl(creall(w), x),
copysignl(cimagl(w), y)));
}
if (x == 0 && y == 0)
return (z);
raise_inexact();
if (ax < SQRT_6_EPSILON / 4 && ay < SQRT_6_EPSILON / 4)
return (z);
do_hard_work(ax, ay, &rx, &B_is_usable, &B, &sqrt_A2my2, &new_y);
if (B_is_usable)
ry = asinl(B);
else
ry = atan2l(new_y, sqrt_A2my2);
return (CMPLXL(copysignl(rx, x), copysignl(ry, y)));
}
/* Equ 20.2, 20.4 pg 126 */
void ln_get_equ_prec2 (struct ln_equ_posn * mean_position, double fromJD, double toJD, struct ln_equ_posn * position)
{
long double t, t2, t3, A, B, C, zeta, eta, theta, ra, dec, mean_ra, mean_dec, T, T2;
/* change original ra and dec to radians */
mean_ra = ln_deg_to_rad (mean_position->ra);
mean_dec = ln_deg_to_rad (mean_position->dec);
/* calc t, T, zeta, eta and theta Equ 20.2 */
T = ((long double) (fromJD - JD2000)) / 36525.0;
T *= 1.0 / 3600.0;
t = ((long double) (toJD - fromJD)) / 36525.0;
t *= 1.0 / 3600.0;
T2 = T * T;
t2 = t * t;
t3 = t2 *t;
zeta = (2306.2181 + 1.39656 * T - 0.000139 * T2) * t + (0.30188 - 0.000344 * T) * t2 + 0.017998 * t3;
eta = (2306.2181 + 1.39656 * T - 0.000139 * T2) * t + (1.09468 + 0.000066 * T) * t2 + 0.018203 * t3;
theta = (2004.3109 - 0.85330 * T - 0.000217 * T2) * t - (0.42665 + 0.000217 * T) * t2 - 0.041833 * t3;
zeta = ln_deg_to_rad (zeta);
eta = ln_deg_to_rad (eta);
theta = ln_deg_to_rad (theta);
/* calc A,B,C equ 20.4 */
A = cosl (mean_dec) * sinl (mean_ra + zeta);
B = cosl (theta) * cosl (mean_dec) * cosl (mean_ra + zeta) - sinl (theta) * sinl (mean_dec);
C = sinl (theta) * cosl (mean_dec) * cosl (mean_ra + zeta) + cosl (theta) * sinl (mean_dec);
ra = atan2l (A,B) + eta;
/* check for object near celestial pole */
if (mean_dec > (0.4 * M_PI) || mean_dec < (-0.4 * M_PI)) {
/* close to pole */
dec = acosl (sqrt(A * A + B * B));
if (mean_dec < 0.)
dec *= -1; /* 0 <= acos() <= PI */
} else {
/* not close to pole */
dec = asinl (C);
}
/* change to degrees */
position->ra = ln_range_degrees (ln_rad_to_deg (ra));
position->dec = ln_rad_to_deg (dec);
}
// Just checking to make sure these library functions are marked readnone
void test_builtins(double d, float f, long double ld) {
// CHECK-NO: @test_builtins
// CHECK-YES: @test_builtins
double atan_ = atan(d);
long double atanl_ = atanl(ld);
float atanf_ = atanf(f);
// CHECK-NO: declare double @atan(double) [[NUW_RN]]
// CHECK-NO: declare x86_fp80 @atanl(x86_fp80) [[NUW_RN]]
// CHECK-NO: declare float @atanf(float) [[NUW_RN]]
// CHECK-YES-NOT: declare double @atan(double) [[NUW_RN]]
// CHECK-YES-NOT: declare x86_fp80 @atanl(x86_fp80) [[NUW_RN]]
// CHECK-YES-NOT: declare float @atanf(float) [[NUW_RN]]
double atan2_ = atan2(d, 2);
long double atan2l_ = atan2l(ld, ld);
float atan2f_ = atan2f(f, f);
// CHECK-NO: declare double @atan2(double, double) [[NUW_RN]]
// CHECK-NO: declare x86_fp80 @atan2l(x86_fp80, x86_fp80) [[NUW_RN]]
// CHECK-NO: declare float @atan2f(float, float) [[NUW_RN]]
// CHECK-YES-NOT: declare double @atan2(double, double) [[NUW_RN]]
// CHECK-YES-NOT: declare x86_fp80 @atan2l(x86_fp80, x86_fp80) [[NUW_RN]]
// CHECK-YES-NOT: declare float @atan2f(float, float) [[NUW_RN]]
double exp_ = exp(d);
long double expl_ = expl(ld);
float expf_ = expf(f);
// CHECK-NO: declare double @exp(double) [[NUW_RN]]
// CHECK-NO: declare x86_fp80 @expl(x86_fp80) [[NUW_RN]]
// CHECK-NO: declare float @expf(float) [[NUW_RN]]
// CHECK-YES-NOT: declare double @exp(double) [[NUW_RN]]
// CHECK-YES-NOT: declare x86_fp80 @expl(x86_fp80) [[NUW_RN]]
// CHECK-YES-NOT: declare float @expf(float) [[NUW_RN]]
double log_ = log(d);
long double logl_ = logl(ld);
float logf_ = logf(f);
// CHECK-NO: declare double @log(double) [[NUW_RN]]
// CHECK-NO: declare x86_fp80 @logl(x86_fp80) [[NUW_RN]]
// CHECK-NO: declare float @logf(float) [[NUW_RN]]
// CHECK-YES-NOT: declare double @log(double) [[NUW_RN]]
// CHECK-YES-NOT: declare x86_fp80 @logl(x86_fp80) [[NUW_RN]]
// CHECK-YES-NOT: declare float @logf(float) [[NUW_RN]]
}
static TACommandVerdict atan2l_cmd(TAThread thread,TAInputStream stream)
{
long double x, y, res;
y = readLongDouble(&stream);
x = readLongDouble(&stream);
START_TARGET_OPERATION(thread);
errno = 0;
res = atan2l(y, x);
END_TARGET_OPERATION(thread);
writeInt(thread, errno);
writeLongDouble(thread, res);
sendResponse(thread);
return taDefaultVerdict;
}
/* Equ 20.3, 20.4 pg 126
*/
void ln_get_equ_prec (struct ln_equ_posn * mean_position, double JD, struct ln_equ_posn * position)
{
long double t, t2, t3, A, B, C, zeta, eta, theta, ra, dec, mean_ra, mean_dec;
/* change original ra and dec to radians */
mean_ra = ln_deg_to_rad (mean_position->ra);
mean_dec = ln_deg_to_rad (mean_position->dec);
/* calc t, zeta, eta and theta for J2000.0 Equ 20.3 */
t = (JD - JD2000) / 36525.0;
t *= 1.0 / 3600.0;
t2 = t * t;
t3 = t2 *t;
zeta = 2306.2181 * t + 0.30188 * t2 + 0.017998 * t3;
eta = 2306.2181 * t + 1.09468 * t2 + 0.041833 * t3;
theta = 2004.3109 * t - 0.42665 * t2 - 0.041833 * t3;
zeta = ln_deg_to_rad (zeta);
eta = ln_deg_to_rad (eta);
theta = ln_deg_to_rad (theta);
/* calc A,B,C equ 20.4 */
A = cosl (mean_dec) * sinl (mean_ra + zeta);
B = cosl (theta) * cosl (mean_dec) * cosl (mean_ra + zeta) - sinl (theta) * sinl (mean_dec);
C = sinl (theta) * cosl (mean_dec) * cosl (mean_ra + zeta) + cosl (theta) * sinl (mean_dec);
ra = atan2l (A,B) + eta;
/* check for object near celestial pole */
if (mean_dec > (0.4 * M_PI) || mean_dec < (-0.4 * M_PI)) {
/* close to pole */
dec = acosl (sqrt(A * A + B * B));
if (mean_dec < 0.)
dec *= -1; /* 0 <= acos() <= PI */
} else {
/* not close to pole */
dec = asinl (C);
}
/* change to degrees */
position->ra = ln_range_degrees (ln_rad_to_deg (ra));
position->dec = ln_rad_to_deg (dec);
}
long double complex
catanl(long double complex z)
{
long double complex w;
long double a, t, x, x2, y;
x = creall(z);
y = cimagl(z);
if ((x == 0.0L) && (y > 1.0L))
goto ovrf;
x2 = x * x;
a = 1.0L - x2 - (y * y);
if (a == 0.0)
goto ovrf;
t = 0.5L * atan2l(2.0L * x, a);
w = _redupil(t);
t = y - 1.0L;
a = x2 + (t * t);
if (a == 0.0L)
goto ovrf;
t = y + 1.0L;
a = (x2 + (t * t))/a;
w = w + (0.25L * logl(a)) * I;
return w;
ovrf:
#if 0
mtherr ("catanl", OVERFLOW);
#endif
w = HUGE_VALL + HUGE_VALL * I;
return w;
}
DLLEXPORT long double
cargl(long double complex z)
{
return (atan2l(cimagl(z), creall(z)));
}
ldcomplex
catanl(ldcomplex z) {
ldcomplex ans;
long double x, y, t1, ax, ay, t;
int hx, hy, ix, iy;
x = LD_RE(z);
y = LD_IM(z);
ax = fabsl(x);
ay = fabsl(y);
hx = HI_XWORD(x);
hy = HI_XWORD(y);
ix = hx & 0x7fffffff;
iy = hy & 0x7fffffff;
/* x is inf or NaN */
if (ix >= 0x7fff0000) {
if (isinfl(x)) {
LD_RE(ans) = pi_2;
LD_IM(ans) = zero;
} else {
LD_RE(ans) = x + x;
if (iszerol(y) || (isinfl(y)))
LD_IM(ans) = zero;
else
LD_IM(ans) = (fabsl(y) - ay) / (fabsl(y) - ay);
}
} else if (iy >= 0x7fff0000) {
/* y is inf or NaN */
if (isinfl(y)) {
LD_RE(ans) = pi_2;
LD_IM(ans) = zero;
} else {
LD_RE(ans) = (fabsl(x) - ax) / (fabsl(x) - ax);
LD_IM(ans) = y;
}
} else if (iszerol(x)) {
/* INDENT OFF */
/*
* x = 0
* 1 1
* A = --- * atan2(2x, 1-x*x-y*y) = --- atan2(0,1-|y|)
* 2 2
*
* 1 [ (y+1)*(y+1) ] 1 2 1 2y
* B = - log [ ----------- ] = - log (1+ ---) or - log(1+ ----)
* 4 [ (y-1)*(y-1) ] 2 y-1 2 1-y
*/
/* INDENT ON */
t = one - ay;
if (ay == one) {
/* y=1: catan(0,1)=(0,+inf) with 1/0 signal */
LD_IM(ans) = ay / ax;
LD_RE(ans) = zero;
} else if (ay > one) { /* y>1 */
LD_IM(ans) = half * log1pl(two / (-t));
LD_RE(ans) = pi_2;
} else { /* y<1 */
LD_IM(ans) = half * log1pl((ay + ay) / t);
LD_RE(ans) = zero;
}
} else if (ay < E * (one + ax)) {
/* INDENT OFF */
/*
* Tiny y (relative to 1+|x|)
* |y| < E*(1+|x|)
* where E=2**-29, -35, -60 for double, extended, quad precision
*
* 1 [x<=1: atan(x)
* A = - * atan2(2x,1-x*x-y*y) ~ [ 1 1+x
* 2 [x>=1: - atan2(2,(1-x)*(-----))
* 2 x
*
* y/x
* B ~ t*(1-2t), where t = ----------------- is tiny
* x + (y-1)*(y-1)/x
*
* y
* (when x < 2**-60, t = ----------- )
* (y-1)*(y-1)
*/
/* INDENT ON */
if (ay == zero)
LD_IM(ans) = ay;
else {
t1 = ay - one;
if (ix < 0x3fc30000)
t = ay / (t1 * t1);
else if (ix > 0x403b0000)
t = (ay / ax) / ax;
else
t = ay / (ax * ax + t1 * t1);
LD_IM(ans) = t * (one - two * t);
}
if (ix < 0x3fff0000)
LD_RE(ans) = atanl(ax);
else
LD_RE(ans) = half * atan2l(two, (one - ax) * (one +
one / ax));
} else if (ay > Einv * (one + ax)) {
/* INDENT OFF */
/*
* Huge y relative to 1+|x|
* |y| > Einv*(1+|x|), where Einv~2**(prec/2+3),
* 1
* A ~ --- * atan2(2x, -y*y) ~ pi/2
* 2
* y
* B ~ t*(1-2t), where t = --------------- is tiny
* (y-1)*(y-1)
*/
/* INDENT ON */
LD_RE(ans) = pi_2;
t = (ay / (ay - one)) / (ay - one);
LD_IM(ans) = t * (one - (t + t));
} else if (ay == one) {
/* INDENT OFF */
/*
* y=1
* 1 1
* A = - * atan2(2x, -x*x) = --- atan2(2,-x)
* 2 2
*
* 1 [ x*x+4] 1 4 [ 0.5(log2-logx) if
* B = - log [ -----] = - log (1+ ---) = [ |x|<E, else 0.25*
* 4 [ x*x ] 4 x*x [ log1p((2/x)*(2/x))
*/
/* INDENT ON */
LD_RE(ans) = half * atan2l(two, -ax);
if (ax < E)
LD_IM(ans) = half * (ln2 - logl(ax));
else {
t = two / ax;
LD_IM(ans) = 0.25L * log1pl(t * t);
}
} else if (ax > Einv * Einv) {
/* INDENT OFF */
/*
* Huge x:
* when |x| > 1/E^2,
* 1 pi
* A ~ --- * atan2(2x, -x*x-y*y) ~ ---
* 2 2
* y y/x
* B ~ t*(1-2t), where t = --------------- = (-------------- )/x
* x*x+(y-1)*(y-1) 1+((y-1)/x)^2
*/
/* INDENT ON */
LD_RE(ans) = pi_2;
t = ((ay / ax) / (one + ((ay - one) / ax) * ((ay - one) /
ax))) / ax;
LD_IM(ans) = t * (one - (t + t));
} else if (ax < E * E * E * E) {
/* INDENT OFF */
/*
* Tiny x:
* when |x| < E^4, (note that y != 1)
* 1 1
* A = --- * atan2(2x, 1-x*x-y*y) ~ --- * atan2(2x,1-y*y)
* 2 2
*
* 1 [ (y+1)*(y+1) ] 1 2 1 2y
* B = - log [ ----------- ] = - log (1+ ---) or - log(1+ ----)
* 4 [ (y-1)*(y-1) ] 2 y-1 2 1-y
*/
/* INDENT ON */
LD_RE(ans) = half * atan2l(ax + ax, (one - ay) * (one + ay));
if (ay > one) /* y>1 */
LD_IM(ans) = half * log1pl(two / (ay - one));
else /* y<1 */
LD_IM(ans) = half * log1pl((ay + ay) / (one - ay));
} else {
/* INDENT OFF */
/*
* normal x,y
* 1
* A = --- * atan2(2x, 1-x*x-y*y)
* 2
*
* 1 [ x*x+(y+1)*(y+1) ] 1 4y
* B = - log [ --------------- ] = - log (1+ -----------------)
* 4 [ x*x+(y-1)*(y-1) ] 4 x*x + (y-1)*(y-1)
*/
/* INDENT ON */
t = one - ay;
if (iy >= 0x3ffe0000 && iy < 0x40000000) {
/* y close to 1 */
LD_RE(ans) = half * (atan2l((ax + ax), (t * (one +
ay) - ax * ax)));
} else if (ix >= 0x3ffe0000 && ix < 0x40000000) {
/* x close to 1 */
LD_RE(ans) = half * atan2l((ax + ax), ((one - ax) *
(one + ax) - ay * ay));
} else
LD_RE(ans) = half * atan2l((ax + ax), ((one - ax *
ax) - ay * ay));
LD_IM(ans) = 0.25L * log1pl((4.0L * ay) / (ax * ax + t * t));
}
if (hx < 0)
LD_RE(ans) = -LD_RE(ans);
if (hy < 0)
LD_IM(ans) = -LD_IM(ans);
return (ans);
}
void
domathl (void)
{
#ifndef NO_LONG_DOUBLE
long double f1;
long double f2;
int i1;
f1 = acosl(0.0);
fprintf( stdout, "acosl : %Lf\n", f1);
f1 = acoshl(0.0);
fprintf( stdout, "acoshl : %Lf\n", f1);
f1 = asinl(1.0);
fprintf( stdout, "asinl : %Lf\n", f1);
f1 = asinhl(1.0);
fprintf( stdout, "asinhl : %Lf\n", f1);
f1 = atanl(M_PI_4);
fprintf( stdout, "atanl : %Lf\n", f1);
f1 = atan2l(2.3, 2.3);
fprintf( stdout, "atan2l : %Lf\n", f1);
f1 = atanhl(1.0);
fprintf( stdout, "atanhl : %Lf\n", f1);
f1 = cbrtl(27.0);
fprintf( stdout, "cbrtl : %Lf\n", f1);
f1 = ceill(3.5);
fprintf( stdout, "ceill : %Lf\n", f1);
f1 = copysignl(3.5, -2.5);
fprintf( stdout, "copysignl : %Lf\n", f1);
f1 = cosl(M_PI_2);
fprintf( stdout, "cosl : %Lf\n", f1);
f1 = coshl(M_PI_2);
fprintf( stdout, "coshl : %Lf\n", f1);
f1 = erfl(42.0);
fprintf( stdout, "erfl : %Lf\n", f1);
f1 = erfcl(42.0);
fprintf( stdout, "erfcl : %Lf\n", f1);
f1 = expl(0.42);
fprintf( stdout, "expl : %Lf\n", f1);
f1 = exp2l(0.42);
fprintf( stdout, "exp2l : %Lf\n", f1);
f1 = expm1l(0.00042);
fprintf( stdout, "expm1l : %Lf\n", f1);
f1 = fabsl(-1.123);
fprintf( stdout, "fabsl : %Lf\n", f1);
f1 = fdiml(1.123, 2.123);
fprintf( stdout, "fdiml : %Lf\n", f1);
f1 = floorl(0.5);
fprintf( stdout, "floorl : %Lf\n", f1);
f1 = floorl(-0.5);
fprintf( stdout, "floorl : %Lf\n", f1);
f1 = fmal(2.1, 2.2, 3.01);
fprintf( stdout, "fmal : %Lf\n", f1);
f1 = fmaxl(-0.42, 0.42);
fprintf( stdout, "fmaxl : %Lf\n", f1);
f1 = fminl(-0.42, 0.42);
fprintf( stdout, "fminl : %Lf\n", f1);
f1 = fmodl(42.0, 3.0);
fprintf( stdout, "fmodl : %Lf\n", f1);
/* no type-specific variant */
i1 = fpclassify(1.0);
fprintf( stdout, "fpclassify : %d\n", i1);
f1 = frexpl(42.0, &i1);
fprintf( stdout, "frexpl : %Lf\n", f1);
f1 = hypotl(42.0, 42.0);
fprintf( stdout, "hypotl : %Lf\n", f1);
i1 = ilogbl(42.0);
fprintf( stdout, "ilogbl : %d\n", i1);
/* no type-specific variant */
i1 = isfinite(3.0);
fprintf( stdout, "isfinite : %d\n", i1);
/* no type-specific variant */
i1 = isgreater(3.0, 3.1);
fprintf( stdout, "isgreater : %d\n", i1);
/* no type-specific variant */
i1 = isgreaterequal(3.0, 3.1);
fprintf( stdout, "isgreaterequal : %d\n", i1);
/* no type-specific variant */
i1 = isinf(3.0);
fprintf( stdout, "isinf : %d\n", i1);
/* no type-specific variant */
i1 = isless(3.0, 3.1);
fprintf( stdout, "isless : %d\n", i1);
/* no type-specific variant */
i1 = islessequal(3.0, 3.1);
fprintf( stdout, "islessequal : %d\n", i1);
/* no type-specific variant */
i1 = islessgreater(3.0, 3.1);
fprintf( stdout, "islessgreater : %d\n", i1);
/* no type-specific variant */
i1 = isnan(0.0);
fprintf( stdout, "isnan : %d\n", i1);
/* no type-specific variant */
i1 = isnormal(3.0);
fprintf( stdout, "isnormal : %d\n", i1);
/* no type-specific variant */
f1 = isunordered(1.0, 2.0);
fprintf( stdout, "isunordered : %d\n", i1);
f1 = j0l(1.2);
fprintf( stdout, "j0l : %Lf\n", f1);
f1 = j1l(1.2);
fprintf( stdout, "j1l : %Lf\n", f1);
f1 = jnl(2,1.2);
fprintf( stdout, "jnl : %Lf\n", f1);
f1 = ldexpl(1.2,3);
fprintf( stdout, "ldexpl : %Lf\n", f1);
f1 = lgammal(42.0);
fprintf( stdout, "lgammal : %Lf\n", f1);
f1 = llrintl(-0.5);
fprintf( stdout, "llrintl : %Lf\n", f1);
f1 = llrintl(0.5);
fprintf( stdout, "llrintl : %Lf\n", f1);
f1 = llroundl(-0.5);
fprintf( stdout, "lroundl : %Lf\n", f1);
f1 = llroundl(0.5);
fprintf( stdout, "lroundl : %Lf\n", f1);
f1 = logl(42.0);
fprintf( stdout, "logl : %Lf\n", f1);
f1 = log10l(42.0);
fprintf( stdout, "log10l : %Lf\n", f1);
f1 = log1pl(42.0);
fprintf( stdout, "log1pl : %Lf\n", f1);
f1 = log2l(42.0);
fprintf( stdout, "log2l : %Lf\n", f1);
f1 = logbl(42.0);
fprintf( stdout, "logbl : %Lf\n", f1);
f1 = lrintl(-0.5);
fprintf( stdout, "lrintl : %Lf\n", f1);
f1 = lrintl(0.5);
fprintf( stdout, "lrintl : %Lf\n", f1);
f1 = lroundl(-0.5);
fprintf( stdout, "lroundl : %Lf\n", f1);
f1 = lroundl(0.5);
fprintf( stdout, "lroundl : %Lf\n", f1);
f1 = modfl(42.0,&f2);
fprintf( stdout, "lmodfl : %Lf\n", f1);
f1 = nanl("");
fprintf( stdout, "nanl : %Lf\n", f1);
f1 = nearbyintl(1.5);
fprintf( stdout, "nearbyintl : %Lf\n", f1);
f1 = nextafterl(1.5,2.0);
fprintf( stdout, "nextafterl : %Lf\n", f1);
f1 = powl(3.01, 2.0);
fprintf( stdout, "powl : %Lf\n", f1);
f1 = remainderl(3.01,2.0);
fprintf( stdout, "remainderl : %Lf\n", f1);
f1 = remquol(29.0,3.0,&i1);
fprintf( stdout, "remquol : %Lf\n", f1);
f1 = rintl(0.5);
fprintf( stdout, "rintl : %Lf\n", f1);
f1 = rintl(-0.5);
fprintf( stdout, "rintl : %Lf\n", f1);
f1 = roundl(0.5);
fprintf( stdout, "roundl : %Lf\n", f1);
f1 = roundl(-0.5);
fprintf( stdout, "roundl : %Lf\n", f1);
f1 = scalblnl(1.2,3);
fprintf( stdout, "scalblnl : %Lf\n", f1);
f1 = scalbnl(1.2,3);
fprintf( stdout, "scalbnl : %Lf\n", f1);
/* no type-specific variant */
i1 = signbit(1.0);
fprintf( stdout, "signbit : %i\n", i1);
f1 = sinl(M_PI_4);
fprintf( stdout, "sinl : %Lf\n", f1);
f1 = sinhl(M_PI_4);
fprintf( stdout, "sinhl : %Lf\n", f1);
f1 = sqrtl(9.0);
fprintf( stdout, "sqrtl : %Lf\n", f1);
f1 = tanl(M_PI_4);
fprintf( stdout, "tanl : %Lf\n", f1);
f1 = tanhl(M_PI_4);
fprintf( stdout, "tanhl : %Lf\n", f1);
f1 = tgammal(2.1);
fprintf( stdout, "tgammal : %Lf\n", f1);
f1 = truncl(3.5);
fprintf( stdout, "truncl : %Lf\n", f1);
f1 = y0l(1.2);
fprintf( stdout, "y0l : %Lf\n", f1);
f1 = y1l(1.2);
fprintf( stdout, "y1l : %Lf\n", f1);
f1 = ynl(3,1.2);
fprintf( stdout, "ynl : %Lf\n", f1);
#endif
}
ldcomplex
cacosl(ldcomplex z) {
long double x, y, t, R, S, A, Am1, B, y2, xm1, xp1, Apx;
int ix, iy, hx, hy;
ldcomplex ans;
x = LD_RE(z);
y = LD_IM(z);
hx = HI_XWORD(x);
hy = HI_XWORD(y);
ix = hx & 0x7fffffff;
iy = hy & 0x7fffffff;
/* x is 0 */
if (x == zero) {
if (y == zero || (iy >= 0x7fff0000)) {
LD_RE(ans) = pi_2 + pi_2_l;
LD_IM(ans) = -y;
return (ans);
}
}
/* |y| is inf or NaN */
if (iy >= 0x7fff0000) {
if (isinfl(y)) { /* cacos(x + i inf) = pi/2 - i inf */
LD_IM(ans) = -y;
if (ix < 0x7fff0000) {
LD_RE(ans) = pi_2 + pi_2_l;
} else if (isinfl(x)) {
if (hx >= 0)
LD_RE(ans) = pi_4 + pi_4_l;
else
LD_RE(ans) = pi3_4 + pi3_4_l;
} else {
LD_RE(ans) = x;
}
} else { /* cacos(x + i NaN) = NaN + i NaN */
LD_RE(ans) = y + x;
if (isinfl(x))
LD_IM(ans) = -fabsl(x);
else
LD_IM(ans) = y;
}
return (ans);
}
y = fabsl(y);
if (ix >= 0x7fff0000) { /* x is inf or NaN */
if (isinfl(x)) { /* x is INF */
LD_IM(ans) = -fabsl(x);
if (iy >= 0x7fff0000) {
if (isinfl(y)) {
/* INDENT OFF */
/* cacos(inf + i inf) = pi/4 - i inf */
/* cacos(-inf+ i inf) =3pi/4 - i inf */
/* INDENT ON */
if (hx >= 0)
LD_RE(ans) = pi_4 + pi_4_l;
else
LD_RE(ans) = pi3_4 + pi3_4_l;
} else
/* INDENT OFF */
/* cacos(inf + i NaN) = NaN - i inf */
/* INDENT ON */
LD_RE(ans) = y + y;
} else {
/* INDENT OFF */
/* cacos(inf + iy ) = 0 - i inf */
/* cacos(-inf+ iy ) = pi - i inf */
/* INDENT ON */
if (hx >= 0)
LD_RE(ans) = zero;
else
LD_RE(ans) = pi + pi_l;
}
} else { /* x is NaN */
/* INDENT OFF */
/*
* cacos(NaN + i inf) = NaN - i inf
* cacos(NaN + i y ) = NaN + i NaN
* cacos(NaN + i NaN) = NaN + i NaN
*/
/* INDENT ON */
LD_RE(ans) = x + y;
if (iy >= 0x7fff0000) {
LD_IM(ans) = -y;
} else {
LD_IM(ans) = x;
}
}
if (hy < 0)
LD_IM(ans) = -LD_IM(ans);
return (ans);
}
if (y == zero) { /* region 1: y=0 */
if (ix < 0x3fff0000) { /* |x| < 1 */
LD_RE(ans) = acosl(x);
LD_IM(ans) = zero;
} else {
LD_RE(ans) = zero;
x = fabsl(x);
if (ix >= ip1) /* i386 ? 2**65 : 2**114 */
LD_IM(ans) = ln2 + logl(x);
else if (ix >= 0x3fff8000) /* x > Acrossover */
LD_IM(ans) = logl(x + sqrtl((x - one) * (x +
one)));
else {
xm1 = x - one;
LD_IM(ans) = log1pl(xm1 + sqrtl(xm1 * (x +
one)));
}
}
} else if (y <= E * fabsl(fabsl(x) - one)) {
/* region 2: y < tiny*||x|-1| */
if (ix < 0x3fff0000) { /* x < 1 */
LD_RE(ans) = acosl(x);
x = fabsl(x);
LD_IM(ans) = y / sqrtl((one + x) * (one - x));
} else if (ix >= ip1) { /* i386 ? 2**65 : 2**114 */
if (hx >= 0)
LD_RE(ans) = y / x;
else {
if (ix >= ip1 + 0x00040000)
LD_RE(ans) = pi + pi_l;
else {
t = pi_l + y / x;
LD_RE(ans) = pi + t;
}
}
LD_IM(ans) = ln2 + logl(fabsl(x));
} else {
x = fabsl(x);
t = sqrtl((x - one) * (x + one));
LD_RE(ans) = (hx >= 0)? y / t : pi - (y / t - pi_l);
if (ix >= 0x3fff8000) /* x > Acrossover */
LD_IM(ans) = logl(x + t);
else
LD_IM(ans) = log1pl(t - (one - x));
}
} else if (y < Foursqrtu) { /* region 3 */
t = sqrtl(y);
LD_RE(ans) = (hx >= 0)? t : pi + pi_l;
LD_IM(ans) = t;
} else if (E * y - one >= fabsl(x)) { /* region 4 */
LD_RE(ans) = pi_2 + pi_2_l;
LD_IM(ans) = ln2 + logl(y);
} else if (ix >= 0x5ffb0000 || iy >= 0x5ffb0000) {
/* region 5: x+1 and y are both (>= sqrt(max)/8) i.e. 2**8188 */
t = x / y;
LD_RE(ans) = atan2l(y, x);
LD_IM(ans) = ln2 + logl(y) + half * log1pl(t * t);
} else if (fabsl(x) < Foursqrtu) {
/* region 6: x is very small, < 4sqrt(min) */
LD_RE(ans) = pi_2 + pi_2_l;
A = sqrtl(one + y * y);
if (iy >= 0x3fff8000) /* if y > Acrossover */
LD_IM(ans) = logl(y + A);
else
LD_IM(ans) = half * log1pl((y + y) * (y + A));
} else { /* safe region */
t = fabsl(x);
y2 = y * y;
xp1 = t + one;
xm1 = t - one;
R = sqrtl(xp1 * xp1 + y2);
S = sqrtl(xm1 * xm1 + y2);
A = half * (R + S);
B = t / A;
if (B <= Bcrossover)
LD_RE(ans) = (hx >= 0)? acosl(B) : acosl(-B);
else { /* use atan and an accurate approx to a-x */
Apx = A + t;
if (t <= one)
LD_RE(ans) = atan2l(sqrtl(half * Apx * (y2 /
(R + xp1) + (S - xm1))), x);
else
LD_RE(ans) = atan2l((y * sqrtl(half * (Apx /
(R + xp1) + Apx / (S + xm1)))), x);
}
if (A <= Acrossover) {
/* use log1p and an accurate approx to A-1 */
if (ix < 0x3fff0000)
Am1 = half * (y2 / (R + xp1) + y2 / (S - xm1));
else
Am1 = half * (y2 / (R + xp1) + (S + xm1));
LD_IM(ans) = log1pl(Am1 + sqrtl(Am1 * (A + one)));
} else {
LD_IM(ans) = logl(A + sqrtl(A * A - one));
}
}
if (hy >= 0)
LD_IM(ans) = -LD_IM(ans);
return (ans);
}
long double acosl(long double x) {
return atan2l(sqrtl(1 - x * x), x);
}
sfloat math_arctan2(const sfloat val1, const sfloat val2)
{
return atan2l(val1, val2);
}
long double
cargl (long double complex z)
{
return atan2l (IMAGPART (z), REALPART (z));
}
void MainWindow::timerEvent(QTimerEvent *)
{
if (cbodies.empty())
{
this->update();
return;
}
long double aX = 0.0;
long double aY = 0.0;
long double a = 0.0;
long double F = 0.0;
long double sinCB = 0.0;
long double cosCB = 0.0;
long double dist_2 = 0.0;
std::pair<long double, long double>* deltaV = new std::pair<long double, long double>[cbodies.size()];
// F = G*m1*m2/r^2
// a = G*m2/r^2
// ax = a.
if (gravityPhysics)
{
for (unsigned i = 0; i < cbodies.size(); i++)
{
for (unsigned j = i+1; j < cbodies.size(); j++)
{
dist_2 = cbodies[i].distance_2(cbodies[j]);
F=(cbodies[i].getMass()*cbodies[j].getMass()/dist_2)*M_G;
cosCB = (cbodies[i].getX()-cbodies[j].getX())/sqrtl(dist_2);
//QDebug(cosCB);
sinCB = (cbodies[i].getY()-cbodies[j].getY())/sqrtl(dist_2);
a=-F/cbodies[i].getMass();
aX = a*cosCB;
aY = a*sinCB;
//cbodies[i].changeVelocity(aX*deltaT/MSEC_IN_SEC,aY*deltaT/MSEC_IN_SEC);
deltaV[i].first += aX*deltaT/MSEC_IN_SEC;
deltaV[i].second += aY*deltaT/MSEC_IN_SEC;
//cbodies[i].move(deltaT);
a=F/cbodies[j].getMass();
aX = a*cosCB;
aY = a*sinCB;
//cbodies[j].changeVelocity(aX*deltaT/MSEC_IN_SEC,aY*deltaT/MSEC_IN_SEC);
deltaV[j].first += aX*deltaT/MSEC_IN_SEC;
deltaV[j].second += aY*deltaT/MSEC_IN_SEC;
//cbodies[j].move(deltaT);
}
}
// for (unsigned i = 0; i < cbodies.size(); i++)
// {
// for (int j = 0; j < cbodies.size(); j++)
// {
// if (i==j)
// continue;
// dist_2 = cbodies[i].distance_2(cbodies[j]);
// cosCB = (cbodies[j].getX()-cbodies[i].getX())/sqrt(dist_2);
// sinCB = (cbodies[j].getY()-cbodies[i].getY())/sqrt(dist_2);
// a = M_G* (cbodies[j].getMass()/dist_2);
// aX = a * cosCB;
// aY = a * sinCB;
// cbodies[i].changeVelocity(aX*deltaT/MSEC_IN_SEC,aY*deltaT/MSEC_IN_SEC);
// cbodies[i].move(deltaT);
// }
// }
}
// odbicia miedzy obiektami
if (bouncyPhysics)
{
for (unsigned i = 0; i < cbodies.size(); i++)
{
for (unsigned j = 0; j < cbodies.size(); j++)
{
if (i == j)
continue;
if (cbodies[i].distance_2(cbodies[j]) > (cbodies[i].getRadius() + cbodies[j].getRadius())*(cbodies[i].getRadius() + cbodies[j].getRadius()))
continue;
// niech cialo a porusza sie wzgledem ciala b, a cialo b bedzie nieruchome
long double deltaPosX = cbodies[i].getX() - cbodies[j].getX();
long double deltaPosY = cbodies[i].getY() - cbodies[j].getY();
long double collisionAngle = atan2l(deltaPosX,deltaPosY);
if (((deltaPosX < 0) xor (cbodies[i].getVx() < 0)) or ((deltaPosY < 0) xor (cbodies[i].getVy() < 0))) // jesli a zbliza sie do b
{
long double deltaVx1, deltaVy1, deltaVx2, deltaVy2; // koncowe roznice szybkosci
long double velocityAngle = atan2l(cbodies[i].getVx(),cbodies[i].getVy());
long double alpha = velocityAngle-collisionAngle;
long double perpendicularAngle = collisionAngle + ((det(deltaPosX,deltaPosY,cbodies[i].getVx(),cbodies[i].getVy())<0)? (-M_PI/2) : (M_PI/2)); // perpendicular to collision angle
long double momentum = sqrtl(cbodies[i].getVx()*cbodies[i].getVx()+cbodies[i].getVy()*cbodies[i].getVy()); // not mult by mass yet
long double momentumX = cbodies[i].getVx()*cbodies[i].getMass();
long double momentumY = cbodies[i].getVy()*cbodies[i].getMass();
long double a = momentum * cosl(alpha);
deltaVx1 = a * cosl(perpendicularAngle);
deltaVy1 = a * sinl(perpendicularAngle);
momentum *= cbodies[i].getMass(); // now it's legit
momentumX -= deltaVx1 * cbodies[i].getMass();
momentumY -= deltaVy1 * cbodies[i].getMass();
deltaVx2 = momentumX/cbodies[j].getMass();
deltaVy2 = momentumY/cbodies[j].getMass();
deltaV[i].first += deltaVx1-cbodies[i].getVx();
deltaV[i].second += deltaVy1-cbodies[i].getVy();
deltaV[j].first += deltaVx2;
deltaV[j].second += deltaVy2;
}
// if (((deltaPosX > 0) xor (cbodies[j].getVx() < 0)) or ((deltaPosY > 0) xor (cbodies[j].getVy() < 0)))
// {
// long double deltaVx1, deltaVy1, deltaVx2, deltaVy2; // koncowe roznice szybkosci
// long double velocityAngle = atan2l(cbodies[i].getVx(),cbodies[i].getVy());
// long double alpha = velocityAngle-collisionAngle;
// long double momentum = sqrtl(cbodies[i].getVx()*cbodies[i].getVx()+cbodies[i].getVy()*cbodies[i].getVy()); // not mult by mass yet
// long double momentumX = cbodies[i].getVx()*cbodies[i].getMass();
// long double momentumY = cbodies[i].getVy()*cbodies[i].getMass();
// long double a = momentum * cosl(alpha);
// deltaVx1 = a * cosl(velocityAngle);
// deltaVy1 = a * sinl(velocityAngle);
// momentum *= cbodies[i].getMass(); // now it's legit
// momentumX -= deltaVx1 * cbodies[i].getMass();
// momentumY -= deltaVy1 * cbodies[i].getMass();
// deltaVx2 = momentumX/cbodies[j].getMass();
// deltaVy2 = momentumY/cbodies[j].getMass();
// deltaV[i].first += deltaVx1;
// deltaV[i].second += deltaVy1;
// deltaV[j].first += deltaVx2;
// deltaV[j].second += deltaVy2;
// }
}
}
}
// dodaj zmiany predkosci
for(unsigned i = 0; i < cbodies.size(); i++)
cbodies[i].changeVelocity(deltaV[i].first,deltaV[i].second);
// sprawdz odbicia od krawedzi ekranu
if (simulationBorder)
{
for (celestialBody &cb:cbodies)
{
if (cb.getWidth()+(int)cb.getX() >= this->width()) // right
cb.setVx(-cb.getVx());
else if ((int)cb.getX()-cb.getWidth() <= 0) // left
cb.setVx(-cb.getVx());
if (cb.getHeight()+(int)cb.getY() >= this->height()) // bottom
cb.setVy(-cb.getVy());
else if ((int)cb.getY()-cb.getHeight() <= 0) // top
cb.setVy(-cb.getVy());
}
}
// przesun obiekty
for(celestialBody &x:cbodies)
x.move(deltaT);
delete [] deltaV;
this->update();
}
