int
main (int argc, char **argv)
{
double a, b, c;
double s, area;
double alpha, beta, gamma;
a = b = c = 0.;
puts ("Zadejte velikost stran a b c:");
scanf ("%lf %lf %lf", &a, &b, &c);
if (!(a > 0 && b > 0 && c > 0))
DIE ("Nespravny vstup.");
if (!(a + b > c && a + c > b && b + c > a))
DIE ("Trojuhelnik neexistuje.");
if (a == b && b == c)
puts ("Trojuhelnik je rovnostranny.");
else if (a == b || b == c || a == c)
puts ("Trojuhelnik je rovnoramenny.");
else
puts ("Trojuhelnik neni ani rovnostranny ani rovnoramenny.");
s = (a + b + c) / 2;
area = sqrt (s * (s - a) * (s - b) * (s - c));
alpha = acos (sqrt (s * (s - a) / b / c)) * 2;
beta = acos (sqrt (s * (s - b) / a / c)) * 2;
gamma = acos (sqrt (s * (s - c) / a / b)) * 2;
/* Přesnost * konstanta * vztaženo k velikosti vstupu */
if (fabs (a * a + b * b - c * c) <= DBL_EPSILON * 64 * c * c
|| fabs (a * a + c * c - b * b) <= DBL_EPSILON * 64 * b * b
|| fabs (b * b + c * c - a * a) <= DBL_EPSILON * 64 * a * a)
puts ("Trojuhelnik je pravouhly.");
else if (alpha > M_PI_2 || beta > M_PI_2 || gamma > M_PI_2)
puts ("Trojuhelnik je tupouhly.");
else
puts ("Trojuhelnik je ostrouhly.");
print_angle ("alfa", alpha);
print_angle ("beta", beta);
print_angle ("gama", gamma);
printf ("Obvod: %.4f\n", a + b + c);
printf ("Obsah: %.4f\n", area);
printf ("Polomer kruznice vepsane: %.4f\n", area / s);
printf ("Polomer kruznice opsane: %.4f\n", a / 2 / sin (alpha));
printf ("Vyska va: %.4f\n", b * sin (gamma));
printf ("Vyska vb: %.4f\n", a * sin (gamma));
printf ("Vyska vc: %.4f\n", a * sin (beta));
return 0;
}
static int angle_table(void)
{
int angle_updates[ITERATIONS + 1];
build_angle_updates(angle_updates);
printf(" type angles_t is array(0 to 19) of unsigned%i;\n", ANGLE_BITS);
printf(" constant angle_off_90 : unsigned%i := ", ANGLE_BITS);
print_angle(-1, angle_updates[ITERATIONS]);
printf(";\n");
printf(" constant angle_update : angles_t :=\n");
printf(" (");
for (int i = 0; i != ITERATIONS; ++i)
print_angle(i, angle_updates[i]);
for (int i = ITERATIONS; i < 20; ++i)
print_angle(i, 0);
return 0;
}
LOCAL bool diff_turn_ang(
float p,
float *ans,
POINTER parameters)
{
Locstate st0 = ((DT_ANG_PARAMS *) parameters)->st0;
Locstate st1 = ((DT_ANG_PARAMS *) parameters)->st1;
float M0sq = ((DT_ANG_PARAMS *) parameters)->M0sq;
float M1sq = ((DT_ANG_PARAMS *) parameters)->M1sq;
float sign0 = ((DT_ANG_PARAMS *) parameters)->sign0;
float sign1 = ((DT_ANG_PARAMS *) parameters)->sign1;
float theta0, theta1;
debug_print("dt_ang","Entered diff_turn_ang()\n");
debug_print("dt_ang","\tp = %g\n",p);
if (steady_state_wave_curve(p,M0sq,&theta0,st0) == FUNCTION_FAILED)
{
screen("WARNING in diff_turn_ang(), ");
screen("steady_state_wave_curve() failed\n");
return FUNCTION_FAILED;
}
if (steady_state_wave_curve(p,M1sq,&theta1,st1) == FUNCTION_FAILED)
{
screen("WARNING in diff_turn_ang(), ");
screen("steady_state_wave_curve() failed\n");
return FUNCTION_FAILED;
}
*ans = sign0*theta0 - sign1*theta1;
if (debugging("dt_ang"))
{
print_angle("\ttheta0 =",theta0,"\n");
print_angle("\ttheta1 =",theta1,"\n");
print_angle("\tans =",*ans,"\n");
}
debug_print("dt_ang","Left diff_turn_ang()\n");
return FUNCTION_SUCCEEDED;
} /*end diff_turn_ang*/
LOCAL bool ip2(
float u, /* trial node angle in computational frame */
float *diff,
POINTER parameters)
{
static const float SMALL_ANG = PI/30.0; /*TOLERANCE*/
static const float twopi_m_small_ang = 2.0*PI - PI/30.0;/*TOLERANCE*/
static const float twopi = 2.0*PI;
static const float halfpi = 0.5*PI;
float node_speed;
float trial_Mach_ang;
float nod_ang_to_inc_ang;
float abs_v[SMAXD]; /*node velocity*/
float Msq; /*steady Mach # sq - temp*/
float pinc_max; /*max pr behind inc shock*/
float prefl_max; /*max pr behind refl shock*/
float inc_shock_speed = ((IP2_PARAMS *)parameters)->inc_shock_speed;
float inc_ang = ((IP2_PARAMS *)parameters)->inc_ang;
float Mach_ang = ((IP2_PARAMS *)parameters)->Mach_ang;
float *refl_ang = ((IP2_PARAMS *)parameters)->refl_ang;
float *contact_ang = ((IP2_PARAMS *)parameters)->contact_ang;
ANGLE_DIRECTION i_to_a_dir= ((IP2_PARAMS *)parameters)->i_to_a_dir;
Locstate ahead = ((IP2_PARAMS *)parameters)->ahead;
Locstate behind = ((IP2_PARAMS *)parameters)->behind;
Locstate refl_bow = ((IP2_PARAMS *)parameters)->refl_bow;
Locstate refl_mach = ((IP2_PARAMS *)parameters)->refl_mach;
static bool first = YES;
static float sin_small_ang;
debug_print("ip2","Entered ip2()\n");
if (first == YES)
{
first = NO;
sin_small_ang = sin(SMALL_ANG);
}
nod_ang_to_inc_ang = normalized_angle(inc_ang - u);
if (fabs(nod_ang_to_inc_ang) < SMALL_ANG ||
fabs(nod_ang_to_inc_ang) > twopi_m_small_ang)
{ /* A GUESS */
node_speed = inc_shock_speed / sin_small_ang;
abs_v[0] = node_speed * cos(u);
abs_v[1] = node_speed * sin(u);
}
else
{
node_speed = inc_shock_speed / fabs(sin(inc_ang - u));
abs_v[0] = node_speed * cos(u);
abs_v[1] = node_speed * sin(u);
}
#if defined(DEBUG_GIPOLAR)
if (debugging("ip2"))
{
print_angle("\ttrial_node_ang =",u,"\n");
print_angle("\tinc_ang =",inc_ang,"\n");
(void) printf("\tinc_shock_speed = %g node_speed = %g\n",
inc_shock_speed,node_speed);
(void) printf("\tabs_v = (%g, %g)\n",abs_v[0],abs_v[1]);
}
#endif /* defined(DEBUG_GIPOLAR) */
if (!i_polar_1(ahead,behind,refl_bow,refl_mach,i_to_a_dir,
abs_v,refl_ang,contact_ang,&trial_Mach_ang))
{
Msq = mach_number_squared(ahead,abs_v,(float *)NULL);
pinc_max = max_behind_shock_pr(Msq,ahead);
Msq = mach_number_squared(behind,abs_v,(float *)NULL);
prefl_max = max_behind_shock_pr(Msq,behind);
if (((prefl_max > pinc_max) && (i_to_a_dir == CLOCKWISE))
||
((prefl_max < pinc_max) && (i_to_a_dir == COUNTER_CLOCK)))
{
*diff = -halfpi;
}
else
{
*diff = halfpi;
}
}
else
{
*diff = Mach_ang - trial_Mach_ang;
#if defined(DEBUG_GIPOLAR)
if (debugging("ip2"))
{
print_angle("\ttrial_Mach_ang =",trial_Mach_ang,"\n");
print_angle("\tdiff =",*diff,"\n");
}
#endif /* defined(DEBUG_GIPOLAR) */
}
*diff = (*diff < PI) ? *diff : *diff - twopi;
*diff = (*diff > -PI) ? *diff : *diff + twopi;
debug_print("ip2","Left ip2()\n");
return FUNCTION_SUCCEEDED;
} /*end ip2*/
EXPORT int intersection_of_two_shock_polars(
Locstate st0,
Locstate st1,
float *abs_v,
float *p,
float *pmin,
float *pmax,
bool Cplus_w0,
bool Cplus_w1,
RIEMANN_SOLVER_WAVE_TYPE *wtype0,
RIEMANN_SOLVER_WAVE_TYPE *wtype1)
{
float v0[MAXD]; /* Velocities in the steady frame */
float v1[MAXD];
float M0sq, M1sq; /* Mach #'s squared in steady frame */
float theta01; /* turn angle vector v0 to v1 */
float v0_x_v1;
float v0_d_v1;
float p0, p1;
float p_upper, p_lower;
const float meps = 10.0*MACH_EPS;/*TOLERANCE*/
float eps_theta;
float eps_pressure;
#if !defined(UNRESTRICTED_THERMODYNAMICS)
float min_pressure;
#endif /* !defined(UNRESTRICTED_THERMODYNAMICS) */
int dim;
DT_ANG_PARAMS parameters;
static char yesstatus[] =
"Left intersection_of_two_shock_polars() status = YES\n";
static char nostatus[] =
"Left intersection_of_two_shock_polars() status = NO\n";
debug_print("shock_polar","Entered intersection_of_two_shock_polars()\n");
dim = Params(st0)->dim;
p0 = pressure(st0);
p1 = pressure(st1);
M0sq = mach_number_squared(st0,abs_v,v0);
M1sq = mach_number_squared(st1,abs_v,v1);
(void) vector_product(v0,v1,&v0_x_v1,dim);
v0_d_v1 = scalar_product(v0,v1,dim);
theta01 = atan2(v0_x_v1,v0_d_v1);
#if defined(DEBUG_GIPOLAR)
if (debugging("shock_polar"))
{
(void) printf("abs_v = (%g, %g)\n",abs_v[0],abs_v[1]);
(void) printf("Cplus_w0 = %s, Cplus_w1 = %s\n",
(Cplus_w0) ? "YES" : "NO",
(Cplus_w1) ? "YES" : "NO");
verbose_print_state("st0",st0);
(void) printf("v0 = (%g, %g), q0 = %g, M0 = %g\n",v0[0],v0[1],
mag_vector(v0,dim),sqrt(M0sq));
verbose_print_state("st1",st1);
(void) printf("v1 = (%g, %g), q1 = %g, M1 = %g\n\n",v1[0],v1[1],
mag_vector(v1,dim),sqrt(M1sq));
print_angle("theta01 =",theta01,"\n");
}
#endif /* defined(DEBUG_GIPOLAR) */
*wtype0 = *wtype1 = UNSET_RIEMANN_SOLVER_WAVE_TYPE;
if (!spolar_intersect_bounds(theta01,M0sq,M1sq,st0,
st1,pmin,pmax,&p_upper,&p_lower,
Cplus_w0,Cplus_w1,wtype0,wtype1))
{
if (debugging("shock_polar"))
{
(void) printf("WARNING in intersection_of_two_shock_polars(), "
"spolar_intersect_bounds() failed.\n");
debug_print("shock_polar",nostatus);
}
return NO;
}
#if !defined(UNRESTRICTED_THERMODYNAMICS)
min_pressure = max(Min_pressure(st0),Min_pressure(st1));
if (p_upper < min_pressure)
{
*p = min_pressure;
*wtype0 = *wtype1 = RAREFACTION;
debug_print("shock_polar",yesstatus);
return YES;
}
#endif /* !defined(UNRESTRICTED_THERMODYNAMICS) */
if (p_upper <= p0) *wtype0 = RAREFACTION;
if (p_lower >= p0) *wtype0 = SHOCK;
if (p_upper <= p1) *wtype1 = RAREFACTION;
if (p_lower >= p1) *wtype1 = SHOCK;
eps_theta = fabs(theta01)*EPS;
eps_theta = max(meps,eps_theta);
eps_pressure = max(p0,p1)*EPS;
eps_pressure = max(meps,eps_pressure);
set_parameters(parameters,Cplus_w0,Cplus_w1,st0,st1,M0sq,M1sq);
if (find_root(diff_turn_ang,(POINTER)¶meters,theta01,p,p_lower,
p_upper,eps_theta,eps_pressure) == FUNCTION_FAILED)
{
if (debugging("shock_polar"))
{
(void) printf("WARNING in intersection_of_two_shock_polars()");
(void) printf(", No intersection of shock polars.\n");
}
debug_print("shock_polar",nostatus);
return NO;
}
*wtype0 = (*p >= p0) ? SHOCK : RAREFACTION;
*wtype1 = (*p >= p1) ? SHOCK : RAREFACTION;
debug_print("shock_polar",yesstatus);
return YES;
} /*end intersection_of_two_shock_polars*/
EXPORT int i_polar_2(
Locstate ahead,
Locstate behind,
Locstate refl_bow,
Locstate refl_mach,
ANGLE_DIRECTION i_to_a_dir,
float *abs_v,
float aw_ang,
float inc_ang,
float *refl_ang,
float *contact_ang,
float Mach_ang)
{
IP2_PARAMS ip2_params;
float inc_shock_speed;
float node_speed;
float node_ang, ans;
float min_ang, max_ang;
float i_n[SMAXD]; /* inc shock normal points to ahead */
float delta, epsilon;
const float meps = MACH_EPS;
debug_print("ipolar2","Entered i_polar_2()\n");
#if defined(DEBUG_GIPOLAR)
if (debugging("ipolar2"))
{
verbose_print_state("ahead",ahead);
verbose_print_state("behind",behind);
print_angle("inc_ang =", inc_ang,"\n");
print_angle("Mach_ang =",Mach_ang,"\n");
print_angle_direction("\ti_to_a_dir =",i_to_a_dir,"\n");
}
#endif /* defined(DEBUG_GIPOLAR) */
/* Find incident shock speed */
if (i_to_a_dir == COUNTER_CLOCK)
{
i_n[0] = cos(inc_ang + PI / 2.);
i_n[1] = sin(inc_ang + PI / 2.);
min_ang = inc_ang;
max_ang = aw_ang;
}
else
{
i_n[0] = cos(inc_ang - PI / 2.);
i_n[1] = sin(inc_ang - PI / 2.);
min_ang = aw_ang;
max_ang = inc_ang;
}
(void) s_polar_4(BEHIND_PRESSURE,pressure(behind),
&inc_shock_speed,i_n,ahead,behind,GAS_STATE);
#if defined(DEBUG_GIPOLAR)
if (debugging("ipolar2"))
{
print_angle("min_ang =", min_ang,"\n");
print_angle("max_ang =",max_ang,"\n");
(void) printf("inc_shock_speed = %g\n",inc_shock_speed);
}
#endif /* defined(DEBUG_GIPOLAR) */
/* Initialize ip2_params */
ip2_params.ahead = ahead;
ip2_params.behind = behind;
ip2_params.refl_bow = refl_bow;
ip2_params.refl_mach = refl_mach;
ip2_params.inc_shock_speed = inc_shock_speed;
ip2_params.inc_ang = inc_ang;
ip2_params.refl_ang = refl_ang;
ip2_params.contact_ang = contact_ang;
ip2_params.Mach_ang = Mach_ang;
ip2_params.i_to_a_dir = i_to_a_dir;
/* Solve for node_angle */
if (min_ang > max_ang) min_ang -= 2. * PI;
delta = EPS*fabs(max_ang-min_ang);
delta = max(delta, meps);
(void) ip2(0.5*(max_ang+min_ang), &epsilon, (POINTER) &ip2_params);
epsilon = fabs(epsilon)*EPS;
epsilon = max(epsilon, meps);
if (debugging("ip2_vals"))
{
print_function_values(ip2,(POINTER) &ip2_params,
0.0,min_ang,max_ang,100,"ip2",stdout);
}
if (find_root(ip2,(POINTER)&ip2_params,0.0,&node_ang,
min_ang,max_ang,epsilon,delta) == FUNCTION_FAILED)
return NO;
/* Since ip2() is a discontinuous function, the root finder may find
an invalid root at the point of discontinuity. Check for this.
*/
(void) ip2(node_ang,&ans,(POINTER) &ip2_params);
if (fabs(ans) > epsilon)
{
if (debugging("ipolar2"))
{
screen("WARNING in i_polar_2(), ");
screen("root_finder returned invalid root\n");
}
return NO;
}
/* Determine node velocity */
node_speed = inc_shock_speed/fabs(sin(inc_ang - node_ang));
abs_v[0] = node_speed * cos(node_ang);
abs_v[1] = node_speed * sin(node_ang);
debug_print("ipolar2","Left i_polar_2()\n");
return YES;
} /*end i_polar_2*/
LOCAL int i_polar_1(
Locstate ahead,
Locstate behind,
Locstate refl_bow,
Locstate refl_mach,
ANGLE_DIRECTION i_to_a_dir,
float *abs_v,
float *refl_ang,
float *cont_ang,
float *mach_ang)
{
float p3;
float theta12; /*turn angle across refl*/
float theta03; /*turn angle across mach*/
float vel0_ang; /*in steady frame*/
float vel1_ang; /* " " " */
float pmax, pmin;
float M0_sq, M1_sq;
float rel_v[MAXD];
bool Cplus_w0; /*wave 0 is mach stem*/
bool Cplus_w1; /*wave 1 is refl wave*/
RIEMANN_SOLVER_WAVE_TYPE wtype0;
RIEMANN_SOLVER_WAVE_TYPE wtype1;
int i, dim = Params(ahead)->dim;
static Locstate st_0 = NULL, st_1 = NULL;
static Locstate st_2 = NULL, st_3 = NULL;
static bool first = YES;
debug_print("ipolar1","Entered i_polar_1()\n");
if (first)
{
size_t sizest = Params(ahead)->sizest;
first = NO;
(*Params(ahead)->_alloc_state)(&st_0,sizest);
(*Params(ahead)->_alloc_state)(&st_1,sizest);
(*Params(ahead)->_alloc_state)(&st_2,sizest);
(*Params(ahead)->_alloc_state)(&st_3,sizest);
}
set_state(st_0,TGAS_STATE,ahead);
set_state(st_1,TGAS_STATE,behind);
if (debugging("ipolar1"))
{
verbose_print_state("ahead",ahead);
verbose_print_state("behind",behind);
(void) printf("\tabs_v[0] = (%g, %g)\n",abs_v[0],abs_v[1]);
print_angle_direction("\ti_to_a_dir =",i_to_a_dir,"\n");
}
M0_sq = mach_number_squared(st_0,abs_v,rel_v);
vel0_ang = angle(rel_v[0],rel_v[1]);
if (debugging("ipolar1"))
{
print_angle("\tvel0 angle =",vel0_ang,"\n");
(void) printf("\tahead Mach number = %g\n",
mag_vector(rel_v,dim)/sound_speed(st_0));
}
if (mag_vector(rel_v,dim) < sound_speed(st_0))
{
if (debugging("ipolar1"))
{
(void) printf("WARNING in i_polar_1(), ");
(void) printf("ahead is subsonic in the rest frame.\n");
}
debug_print("ipolar1","Left i_polar_1()\n");
return NO;
}
M1_sq = mach_number_squared(st_1,abs_v,rel_v);
if (debugging("ipolar1"))
{
vel1_ang = angle(rel_v[0],rel_v[1]);
print_angle("\tvel1 angle =",vel1_ang,"\n");
(void) printf("\tst1 Mach number = %g\n",sqrt(M1_sq));
}
if (mag_vector(rel_v,dim) < sound_speed(st_1))
{
if (debugging("ipolar1"))
{
(void) printf("WARNING in i_polar_1(), ");
(void) printf("behind is subsonic in the rest frame.\n");
}
debug_print("ipolar1","Left i_polar_1()\n");
return NO;
}
if (i_to_a_dir == CLOCKWISE)
{
Cplus_w0 = YES;
Cplus_w1 = NO;
}
else
{
Cplus_w0 = NO;
Cplus_w1 = YES;
}
if (pr_at_max_turn_angle(&pmin,M0_sq,st_0) == FUNCTION_FAILED)
{
if (debugging("ipolar1"))
{
(void) printf("WARNING in i_polar_1(), ");
(void) printf("pr_at_max_turn_angle() failed\n");
}
return NO;
}
pmax = max_behind_shock_pr(M1_sq,st_1);
if (!intersection_of_two_shock_polars(st_0,st_1,abs_v,&p3,
&pmin,&pmax,Cplus_w0,
Cplus_w1,&wtype0,&wtype1))
{
if (debugging("ipolar1"))
{
(void) printf("WARNING in i_polar_1(), ");
(void) printf("unable to compute refl_mach pressure\n");
}
debug_print("ipolar1","Left i_polar_1()\n");
return NO;
}
if ((wtype0 != SHOCK) || (wtype1 != SHOCK))
{
if (debugging("ipolar1"))
{
(void) printf("WARNING in i_polar_1() -- ");
(void) printf("non-shock wave types.\n");
}
debug_print("ipolar1","Left i_polar_1()\n");
return NO;
}
if (!s_polar_3(st_1,YES,p3,Cplus_w1,YES,abs_v,st_2,
refl_ang,&theta12))
{
if (debugging("ipolar1"))
{
(void) printf("WARNING in i_polar_1() -- ");
(void) printf("unable to compute refl_bow.\n");
}
debug_print("ipolar1","Left i_polar_1()\n");
return NO;
}
if (!s_polar_3(st_0,YES,p3,Cplus_w0,YES,abs_v,st_3,
mach_ang,&theta03))
{
if (debugging("ipolar1"))
{
(void) printf("WARNING in i_polar_1() -- ");
(void) printf("unable to compute refl_mach.\n");
}
debug_print("ipolar1","Left i_polar_1()\n");
return NO;
}
*cont_ang = normalized_angle(vel0_ang + theta03);
set_state(refl_bow,GAS_STATE,st_2);
set_state(refl_mach,GAS_STATE,st_3);
if (debugging("ipolar1"))
{
float ang;
(void) printf("\n");
print_angle("\trefl angle = %g d\n",*refl_ang,"\n");
print_angle("\tcont angle = %g d\n",*cont_ang,"\n");
print_angle("\tMach angle = %g d\n",*mach_ang,"\n");
print_angle("\ttheta12 = %g d\n",theta12,"\n");
print_angle("\ttheta03 = %g d\n",theta03,"\n");
for (i = 0; i < dim; i++)
rel_v[i] = vel(i,st_2) - abs_v[i];
ang = angle(rel_v[0],rel_v[1]);
print_angle("\tvel2_ang =",ang,"\n");
for (i = 0; i < dim; i++)
rel_v[i] = vel(i,st_3) - abs_v[i];
ang = angle(rel_v[0],rel_v[1]);
print_angle("\tvel3_ang =",ang,"\n");
ang = (vel1_ang+theta12) - (vel0_ang+theta03);
print_angle("(vel1_ang+theta12) - (vel0_ang+theta03) =",
ang,"\n");
verbose_print_state("refl_bow",refl_bow);
verbose_print_state("refl_mach",refl_mach);
}
debug_print("ipolar1","Left i_polar_1()\n");
return YES;
} /*end i_polar_1*/
