¿Qué es el arco tangente?
El arcotangente es el inverso de la función tangente. Devuelve el ángulo cuya tangente es el número dado.
catan() es una función incorporada en el archivo de encabezado <complex.h> que devuelve la tangente inversa compleja (o arcotangente) de cualquier constante, que divide el eje imaginario sobre la base de la tangente inversa en el intervalo cerrado [-i, +i] (donde i representa iota), utilizado para la evaluación de un objeto complejo, digamos que z está en un eje imaginario, mientras que para determinar un objeto complejo que es real o entero, luego invoca internamente métodos predefinidos como:
| S. No. |
Método |
Tipo de retorno |
|
1. |
La función atan() toma un complejo z de tipo de datos doble que determina el arco tangente para números complejos reales |
Devuelve el arco tangente complejo que se encuentra en un rango a lo largo del eje real [-PI/2, +PI/2] para un argumento de tipo double. |
|
2. |
La función atanf() toma un complejo z de tipo de datos flotante doble que determina el arco tangente para números complejos reales. |
Devuelve el arco tangente complejo que se encuentra en un rango a lo largo del eje real [-PI/2, +PI/2] para un argumento de tipo flotante. |
|
3. |
La función atanl() toma un complejo z de tipo de datos long double que determina el arco tangente para números complejos reales |
Devuelve el arco tangente complejo que se encuentra en un rango a lo largo del eje real [-PI/2, +PI/2] para un argumento de tipo long double. |
|
4. |
La función catan() toma un complejo z de tipo de datos doble que también permite una parte imaginaria de números complejos | Devuelve el arco tangente complejo que se encuentra en un rango a lo largo del eje imaginario [-i, +i] para un objeto complejo de tipo doble |
|
5. |
La función catanf() toma una z compleja de tipo de datos float double que también permite una parte imaginaria de números complejos | Devuelve el arco tangente complejo que se encuentra en un rango a lo largo del eje imaginario [-i, +i] para un objeto complejo de tipo float |
|
6. |
La función catanl() toma una z compleja de tipo de datos long double que también permite una parte imaginaria de números complejos | Devuelve el arco tangente complejo que se encuentra en un rango a lo largo del eje imaginario [-i, +i] para un objeto complejo de tipo long double |
Sintaxis:
atan(double arg); atanf(float arg); atanl(long double arg); where arg is a floating-point value catan(double complex z); catanf(float complex z); catanl( long double complex z); where z is a Type – generic macro
Parámetro: Estas funciones aceptan un parámetro obligatorio z que especifica la tangente inversa. El parámetro puede ser de tipo de datos double, float o long double .
Valor devuelto: Esta función devuelve arco tangente/arco tangente complejo según el tipo de argumento pasado.
A continuación se muestran los programas que ilustran el método anterior:
Programa 1 : este programa ilustrará las funciones atan() , atanf() y atanl() calcula el valor principal del arco tangente del argumento de punto flotante. Si se produce un error de rango debido a un desbordamiento, se devuelve el resultado correcto después del redondeo.
C
// C program to illustrate the use
// of functions atan(), atanf(),
// and atanl()
#include <math.h>
#include <stdio.h>
// Driver Code
int main()
{
// For function atan()
printf("atan(1) = %lf, ",
atan(1));
printf(" 4*atan(1)=%lf\n",
4 * atan(1));
printf("atan(-0.0) = %+lf, ",
atan(-0.0));
printf("atan(+0.0) = %+lf\n",
atan(0));
// For special values INFINITY
printf("atan(Inf) = %lf, ",
atan(INFINITY));
printf("2*atan(Inf) = %lf\n\n",
2 * atan(INFINITY));
// For function atanf()
printf("atanf(1.1) = %f, ",
atanf(1.1));
printf("4*atanf(1.5)=%f\n",
4 * atanf(1.5));
printf("atanf(-0.3) = %+f, ",
atanf(-0.3));
printf("atanf(+0.3) = %+f\n",
atanf(0.3));
// For special values INFINITY
printf("atanf(Inf) = %f, ",
atanf(INFINITY));
printf("2*atanf(Inf) = %f\n\n",
2 * atanf(INFINITY));
// For function atanl()
printf("atanl(1.1) = %Lf, ",
atanl(1.1));
printf("4*atanl(1.7)=%Lf\n",
4 * atanl(1.7));
printf("atanl(-1.3) = %+Lf, ",
atanl(-1.3));
printf("atanl(+0.3) = %+Lf\n",
atanl(0.3));
// For special values INFINITY
printf("atanl(Inf) = %Lf, ",
atanl(INFINITY));
printf("2*atanl(Inf) = %Lf\n\n",
2 * atanl(INFINITY));
return 0;
}
atan(1) = 0.785398, 4*atan(1)=3.141593 atan(-0.0) = -0.000000, atan(+0.0) = +0.000000 atan(Inf) = 1.570796, 2*atan(Inf) = 3.141593 atanf(1.1) = 0.832981, 4*atanf(1.5)=3.931175 atanf(-0.3) = -0.291457, atanf(+0.3) = +0.291457 atanf(Inf) = 1.570796, 2*atanf(Inf) = 3.141593 atanl(1.1) = 0.832981, 4*atanl(1.7)=4.156289 atanl(-1.3) = -0.915101, atanl(+0.3) = +0.291457 atanl(Inf) = 1.570796, 2*atanl(Inf) = 3.141593
Programa 2 : este programa ilustrará las funciones catan() , catanf() y catanl() calcula el valor principal del arco tangente de un número complejo como argumento.
C
// C program to illustrate the use
// of functions catan(), catanf(),
// and catanl()
#include <complex.h>
#include <float.h>
#include <stdio.h>
// Driver Code
int main()
{
// Given Complex Number
double complex z1 = catan(2 * I);
// Function catan()
printf("catan(+0 + 2i) = %lf + %lfi\n",
creal(z1), cimag(z1));
// Complex(0, + INFINITY)
double complex z2 = 2
* catan(2 * I * DBL_MAX);
printf("2*catan(+0 + i*Inf) = %lf%+lfi\n",
creal(z2), cimag(z2));
printf("\n");
// Function catanf()
float complex z3 = catanf(2 * I);
printf("catanf(+0 + 2i) = %f + %fi\n",
crealf(z3), cimagf(z3));
// Complex(0, + INFINITY)
float complex z4 = 2
* catanf(2 * I * DBL_MAX);
printf("2*catanf(+0 + i*Inf) = %f + %fi\n",
crealf(z4), cimagf(z4));
printf("\n");
// Function catanl()
long double complex z5 = catanl(2 * I);
printf("catan(+0+2i) = %Lf%+Lfi\n",
creall(z5), cimagl(z5));
// Complex(0, + INFINITY)
long double complex z6 = 2
* catanl(2 * I * DBL_MAX);
printf("2*catanl(+0 + i*Inf) = %Lf + %Lfi\n",
creall(z6), cimagl(z6));
}
catan(+0 + 2i) = 1.570796 + 0.549306i 2*catan(+0 + i*Inf) = 3.141593+0.000000i catanf(+0 + 2i) = 1.570796 + 0.549306i 2*catanf(+0 + i*Inf) = 3.141593 + 0.000000i catan(+0+2i) = 1.570796+0.549306i 2*catanl(+0 + i*Inf) = 3.141593 + 0.000000i
Programa 3 : Este programa ilustrará las funciones catanh() , catanhf() , y catanhl() calcula el arco tangente hiperbólico complejo de z a lo largo del eje real y en el intervalo [-i*PI/2, +i*PI/ 2] a lo largo del eje imaginario.
C
// C program to illustrate the use
// of functions catanh(), catanhf(),
// and catanhl()
#include <complex.h>
#include <stdio.h>
// Driver Code
int main()
{
// Function catanh()
double complex z1 = catanh(2);
printf("catanh(+2+0i) = %lf%+lfi\n",
creal(z1), cimag(z1));
// for any z, atanh(z) = atan(iz)/i
// I denotes Imaginary
// part of the complex number
double complex z2 = catanh(1 + 2 * I);
printf("catanh(1+2i) = %lf%+lfi\n\n",
creal(z2), cimag(z2));
// Function catanhf()
float complex z3 = catanhf(2);
printf("catanhf(+2+0i) = %f%+fi\n",
crealf(z3), cimagf(z3));
// for any z, atanh(z) = atan(iz)/i
float complex z4 = catanhf(1 + 2 * I);
printf("catanhf(1+2i) = %f%+fi\n\n",
crealf(z4), cimagf(z4));
// Function catanh()
long double complex z5 = catanhl(2);
printf("catanhl(+2+0i) = %Lf%+Lfi\n",
creall(z5), cimagl(z5));
// for any z, atanh(z) = atan(iz)/i
long double complex z6 = catanhl(1 + 2 * I);
printf("catanhl(1+2i) = %Lf%+Lfi\n\n",
creall(z6), cimagl(z6));
}
catanh(+2+0i) = 0.549306+1.570796i catanh(1+2i) = 0.173287+1.178097i catanhf(+2+0i) = 0.549306+1.570796i catanhf(1+2i) = 0.173287+1.178097i catanhl(+2+0i) = 0.549306+1.570796i catanhl(1+2i) = 0.173287+1.178097i
Publicación traducida automáticamente
Artículo escrito por satvikshrivas26 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA