void
SenoHiperbolico (Token ** Pila)
{
Token *Operando = EntornoEjecucion_BuscaSimbolo (*Pila);
if (Buzon.GetHuboError ())
return;
if (NoEsReal (Operando))
{
BorrarTokenSiEsVariable (Operando);
return;
}
long double ValorDominio = Operando->GetDatoReal ();
BorrarTokenSiEsVariable (Operando);
long double ValorRetorno = sinhl (ValorDominio);
if (Buzon.GetHuboError ())
return;
Token *TokenRetorno = ConsigueToken (ValorRetorno);
if (Buzon.GetHuboError ())
return;
delete Desapila (Pila);
Apila (Pila, TokenRetorno);
if (FueraDeRango (TokenRetorno))
return;
return;
}
long double complex CLANG_PORT_DECL(ccosl) (long double complex Z)
{
long double complex Res;
__real__ Res = cosl (__real__ Z) * coshl ( __imag__ Z);
__imag__ Res = -sinl (__real__ Z) * sinhl ( __imag__ Z);
return Res;
}
static TACommandVerdict sinhl_cmd(TAThread thread,TAInputStream stream)
{
long double x, res;
// Prepare
x = readLongDouble(&stream);
errno = 0;
START_TARGET_OPERATION(thread);
// Execute
res = sinhl(x);
END_TARGET_OPERATION(thread);
// Response
writeLongDouble(thread, res);
writeInt(thread, errno);
sendResponse(thread);
return taDefaultVerdict;
}
void test_sinh()
{
static_assert((std::is_same<decltype(sinh((double)0)), double>::value), "");
static_assert((std::is_same<decltype(sinhf(0)), float>::value), "");
static_assert((std::is_same<decltype(sinhl(0)), long double>::value), "");
assert(sinh(0) == 0);
}
long double complex ccosl (long double complex Z)
{
long double complex Res;
__real__ Res = cosl (__real__ Z) * coshl ( __imag__ Z);
__imag__ Res = -sinl (__real__ Z) * sinhl ( __imag__ Z);
return Res;
}
ldcomplex
csinhl(ldcomplex z) {
long double t, x, y, S, C;
int hx, ix, hy, iy, n;
ldcomplex ans;
x = LD_RE(z);
y = LD_IM(z);
hx = HI_XWORD(x);
ix = hx & 0x7fffffff;
hy = HI_XWORD(y);
iy = hy & 0x7fffffff;
x = fabsl(x);
y = fabsl(y);
(void) sincosl(y, &S, &C);
if (ix >= 0x4004e000) { /* |x| > 60 = prec/2 (14,28,34,60) */
if (ix >= 0x400C62E4) { /* |x| > 11356.52... ~ log(2**16384) */
if (ix >= 0x7fff0000) { /* |x| is inf or NaN */
if (y == zero) {
LD_RE(ans) = x;
LD_IM(ans) = y;
} else if (iy >= 0x7fff0000) {
LD_RE(ans) = x;
LD_IM(ans) = x - y;
} else {
LD_RE(ans) = C * x;
LD_IM(ans) = S * x;
}
} else {
/* return exp(x)=t*2**n */
t = __k_cexpl(x, &n);
LD_RE(ans) = scalbnl(C * t, n - 1);
LD_IM(ans) = scalbnl(S * t, n - 1);
}
} else {
t = expl(x) * half;
LD_RE(ans) = C * t;
LD_IM(ans) = S * t;
}
} else {
if (x == zero) { /* x = 0, return (0,S) */
LD_RE(ans) = zero;
LD_IM(ans) = S;
} else {
LD_RE(ans) = C * sinhl(x);
LD_IM(ans) = S * coshl(x);
}
}
if (hx < 0)
LD_RE(ans) = -LD_RE(ans);
if (hy < 0)
LD_IM(ans) = -LD_IM(ans);
return (ans);
}
long double complex
ccoshl (long double complex a)
{
long double r, i;
long double complex v;
r = REALPART (a);
i = IMAGPART (a);
COMPLEX_ASSIGN (v, coshl (r) * cosl (i), - (sinhl (r) * sinl (i)));
return v;
}
long double complex
csinhl(long double complex z)
{
long double complex w;
long double x, y;
x = creall(z);
y = cimagl(z);
w = sinhl(x) * cosl(y) + (coshl(x) * sinl(y)) * I;
return w;
}
long double TSolver::gcalc(const char f,const long double a,const long double b,const long double step) //calculates function
{
#define ain(x) (a-step<=x && a+step>=x)
#define bin(x) (b-step<=x && b+step>=x)
#define angin(x) (torad(a)-step<x && torad(a)+step>x)
switch (f)
{case '+' : return a+b;
case '-' : return a-b;
case '*' : return a*b;
case '/' : if (bin(0)) {Err=E_DEV_ZERO;return 0;};return a/b;
case '!' : if (floorl(a)!=a) {Err=E_ARG;return 0;}return factor(a);
case '_' : return -a;
case cpi : return M_PI;
case cx : return X;
case fexp : return exp(a);
case fln : if (a<0) {Err=E_ARG;return 0;}return logl(a);
case flog : if (a<0) {Err=E_ARG;return 0;}return log10l(a);
case flogn : if (a<0) {Err=E_ARG;return 0;}return log(a)/log(b);
case '^':
case f_op_pow:
case fpow : if (a<0 && b<1 && b>0 && (!fmodl(b,2))) {Err=E_ARG;return 0;}return powl(a,b);
case fsqr : return a*a;
case f_op_root:
case froot : if (a<0 && (!fmodl(b,2))){Err=E_ARG;return 0;}
return (a>0 || (!fmodl(b,2)))?powl(a,1/b):-powl(-a,1/b);
case fsqrt : if (a<0) {Err=E_ARG;return 0;}return sqrtl(a);
case f_abs : return fabsl(a);
case fsin : return sinl(a);
case fcos : return cosl(a);
case ftan : if (angin(M_PI_2) || angin(M_PI_2+M_PI)) {Err=E_ARG;return 0;} return tanl(a);
case fctan : if (angin(0) || angin(M_PI)) {Err=E_ARG;return 0;} return 1/tanl(a);
case fsin+ARC : if (fabsl(a)>1) {Err=E_ARG;return 0;} return asinl(a);
case fcos+ARC : if (fabsl(a)>1) {Err=E_ARG;return 0;} return acosl(a);
case ftan+ARC : return atanl(a);
case fctan+ARC: return atanl(1/a);
case fsin+HYP : return sinhl(a);
case fcos+HYP : return coshl(a);
case ftan+HYP : return tanhl(a);
case fctan+HYP : return 1/tanhl(a);
#ifndef _OLD_
case fsin+HYP+ARC : return asinhl(a);
case fcos+HYP+ARC : return acoshl(a);
case ftan+HYP+ARC : if (fabsl(a)>=1) {Err=E_ARG;return 0;} return atanhl(a);
case fctan+HYP+ARC : if (angin(0)) {Err=E_ARG;return 0;} return atanhl(1/a);
#endif
default: return 0;
}
}
long double complex
ctanhl(long double complex z)
{
long double complex w;
long double x, y, d;
x = creall(z);
y = cimagl(z);
d = coshl(2.0L * x) + cosl(2.0L * y);
w = sinhl(2.0L * x) / d + (sinl(2.0L * y) / d) * I;
return (w);
}
void
_cchshl(long double x, long double *c, long double *s)
{
long double e, ei;
if (fabsl(x) <= 0.5L) {
*c = coshl(x);
*s = sinhl(x);
} else {
e = expl(x);
ei = 0.5L / e;
e = 0.5L * e;
*s = e - ei;
*c = e + ei;
}
}
LONG_DOUBLE eval_expr_func(eval_context *ctx, ast_node *tree) {
expr_func_data *func_data = (expr_func_data*)tree->data;
if (strcmp(func_data->name, "sin") == 0) return sinl(eval_expr(ctx, func_data->rhs));
else if (strcmp(func_data->name, "cos") == 0) return cosl(eval_expr(ctx, func_data->rhs));
else if (strcmp(func_data->name, "tan") == 0) return tanl(eval_expr(ctx, func_data->rhs));
else if (strcmp(func_data->name, "acos") == 0) return acosl(eval_expr(ctx, func_data->rhs));
else if (strcmp(func_data->name, "asin") == 0) return asinl(eval_expr(ctx, func_data->rhs));
else if (strcmp(func_data->name, "atan") == 0) return atanl(eval_expr(ctx, func_data->rhs));
else if (strcmp(func_data->name, "cosh") == 0) return coshl(eval_expr(ctx, func_data->rhs));
else if (strcmp(func_data->name, "sinh") == 0) return sinhl(eval_expr(ctx, func_data->rhs));
else if (strcmp(func_data->name, "tanh") == 0) return tanhl(eval_expr(ctx, func_data->rhs));
else if (strcmp(func_data->name, "log") == 0) return logl(eval_expr(ctx, func_data->rhs));
else if (strcmp(func_data->name, "log10") == 0) return log10l(eval_expr(ctx, func_data->rhs));
else if (strcmp(func_data->name, "ceil") == 0) return ceill(eval_expr(ctx, func_data->rhs));
else if (strcmp(func_data->name, "fabs") == 0) return fabsl(eval_expr(ctx, func_data->rhs));
else if (strcmp(func_data->name, "floor") == 0) return floorl(eval_expr(ctx, func_data->rhs));
else if (strcmp(func_data->name, "sqrt") == 0) return sqrtl(eval_expr(ctx, func_data->rhs));
else return eval_emit_error(ctx, "Unknown function %s.", func_data->name);
}
long double complex
ctanl(long double complex z)
{
long double complex w;
long double d;
d = cosl(2.0L * creall(z)) + coshl(2.0L * cimagl(z));
if (fabsl(d) < 0.25L)
d = _ctansl(z);
if (d == 0.0L) {
/* mtherr ("ctan", OVERFLOW); */
w = MAXNUM + MAXNUM * I;
return w;
}
w = sinl(2.0L * creall(z)) / d + (sinhl(2.0L * cimagl(z)) / d) * I;
return w;
}
long double tanhl(long double x)
{
return sinhl(x) / coshl(x);
}
static int testl(long double long_double_x, int int_x, long long_x)
{
int r = 0;
r += __finitel(long_double_x);
r += __fpclassifyl(long_double_x);
r += __isinfl(long_double_x);
r += __isnanl(long_double_x);
r += __signbitl(long_double_x);
r += acoshl(long_double_x);
r += acosl(long_double_x);
r += asinhl(long_double_x);
r += asinl(long_double_x);
r += atan2l(long_double_x, long_double_x);
r += atanhl(long_double_x);
r += atanl(long_double_x);
r += cbrtl(long_double_x);
r += ceill(long_double_x);
r += copysignl(long_double_x, long_double_x);
r += coshl(long_double_x);
r += cosl(long_double_x);
r += erfcl(long_double_x);
r += erfl(long_double_x);
r += exp2l(long_double_x);
r += expl(long_double_x);
r += expm1l(long_double_x);
r += fabsl(long_double_x);
r += fdiml(long_double_x, long_double_x);
r += floorl(long_double_x);
r += fmal(long_double_x, long_double_x, long_double_x);
r += fmaxl(long_double_x, long_double_x);
r += fminl(long_double_x, long_double_x);
r += fmodl(long_double_x, long_double_x);
r += frexpl(long_double_x, &int_x);
r += hypotl(long_double_x, long_double_x);
r += ilogbl(long_double_x);
r += ldexpl(long_double_x, int_x);
r += lgammal(long_double_x);
r += llrintl(long_double_x);
r += llroundl(long_double_x);
r += log10l(long_double_x);
r += log1pl(long_double_x);
r += log2l(long_double_x);
r += logbl(long_double_x);
r += logl(long_double_x);
r += lrintl(long_double_x);
r += lroundl(long_double_x);
r += modfl(long_double_x, &long_double_x);
r += nearbyintl(long_double_x);
r += nextafterl(long_double_x, long_double_x);
r += nexttowardl(long_double_x, long_double_x);
r += powl(long_double_x, long_double_x);
r += remainderl(long_double_x, long_double_x);
r += remquol(long_double_x, long_double_x, &int_x);
r += rintl(long_double_x);
r += roundl(long_double_x);
r += scalblnl(long_double_x, long_x);
r += scalbnl(long_double_x, int_x);
r += sinhl(long_double_x);
r += sinl(long_double_x);
r += sqrtl(long_double_x);
r += tanhl(long_double_x);
r += tanl(long_double_x);
r += tgammal(long_double_x);
r += truncl(long_double_x);
return r;
}
TEST(math, sinhl) {
ASSERT_FLOAT_EQ(0.0, sinhl(0.0));
}
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
}
TEST(math, sinhl) {
ASSERT_DOUBLE_EQ(0.0L, sinhl(0.0L));
}
npy_longdouble npy_sinhl(npy_longdouble x)
{
return sinhl(x);
}
