Cómo encontrar arcotangente con ejemplos

¿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;
}
Producción:

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));
}
Producción:

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));
}
Producción:

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

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *