Conversión de Ángulos Radianes a Sexagesimales en C++: Cálculo de Grados, Minutos, Segundos y Cuadrantes

Conversión de Ángulos Radianes a Sexagesimales y Determinación de Cuadrantes en C++

Este documento presenta la implementación en C++ de un programa diseñado para convertir ángulos expresados en radianes a su formato sexagesimal (grados, minutos y segundos), y para determinar el cuadrante en el que se encuentra cada ángulo. El programa utiliza una estructura de datos para almacenar la información de cada ángulo y organiza la lógica en funciones modulares para una mejor legibilidad y mantenimiento.

Descripción del Programa

El objetivo principal es procesar una cantidad N de ángulos ingresados por el usuario en radianes. Para cada ángulo, el sistema realizará las siguientes operaciones:

• Conversión a formato sexagesimal: Transformará el valor en radianes a grados, minutos y segundos.
• Determinación del cuadrante: Identificará en qué cuadrante del plano cartesiano se ubica el ángulo.
• Almacenamiento estructurado: Guardará todos los datos relevantes (radianes, grados, minutos, segundos y cuadrante) en una tabla (implementada como un arreglo de estructuras).
• Visualización de resultados: Mostrará el contenido completo de la tabla una vez procesados todos los ángulos.

Estructura de Datos

Se define una estructura llamada tabla para almacenar la información de cada ángulo. Esta estructura contiene los siguientes campos:

• rad: Ángulo original en radianes (tipo float).
• grad: Parte entera de los grados (tipo int).
• min: Parte entera de los minutos (tipo int).
• seg: Parte decimal de los segundos (tipo float).
• cuad: Cadena de caracteres que indica el cuadrante (arreglo char[20]).

Se declara un arreglo global lista[100] de esta estructura para almacenar hasta 100 ángulos.

Implementación del Código en C++

A continuación, se presenta el código fuente corregido y comentado, estructurado en las funciones principales que realizan las tareas descritas.

#include <iostream> // Para operaciones de entrada/salida (cout, cin)
#include <cmath>    // Para funciones matemáticas como M_PI (valor de pi) y fmod
#include <iomanip>  // Para manipulación del formato de salida (setprecision, fixed)
#include <cstdlib>  // Para funciones generales como system (ej. system("cls"))
#include <cstring>  // Para manipulación de cadenas de caracteres (strcpy)

// Se utiliza el espacio de nombres estándar para simplificar el código
using namespace std;

/*
 * Este programa permite el ingreso de N ángulos expresados en radianes.
 * La finalidad es transformar cada ángulo a su equivalente en formato sexagesimal
 * (grados, minutos y segundos).
 * El programa debe utilizar una función para almacenar los datos en una estructura
 * (tabla) compuesta por 5 campos:
 *   - El ángulo en radianes.
 *   - La cantidad de grados del ángulo.
 *   - La cantidad de minutos del ángulo.
 *   - La cantidad de segundos del ángulo.
 *   - El cuadrante en que se encuentra el ángulo.
 * Finalmente, otra función se encargará de mostrar todo el contenido de la tabla.
 */

// Prototipos de las funciones
void funcion(int n); // Función para ingresar, convertir y calcular cuadrantes
void mostrar(int n); // Función para mostrar el contenido de la tabla

// Definición de la estructura para almacenar los datos de cada ángulo
typedef struct
{
    float rad;      // Ángulo en radianes
    int grad;       // Parte entera de los grados
    int min;        // Parte entera de los minutos
    float seg;      // Parte decimal de los segundos
    char cuad[20];  // Cuadrante al que pertenece el ángulo
} tabla;

// Declaración de un arreglo global de la estructura 'tabla' para almacenar hasta 100 ángulos
tabla lista[100];

/**
 * @brief Función principal del programa.
 * Solicita al usuario la cantidad de ángulos, llama a las funciones de procesamiento
 * y visualización.
 * @return 0 si el programa finaliza correctamente.
 */
int main()
{
    int n; // Variable para almacenar la cantidad de ángulos
    cout << "Ingrese la cantidad de ángulos a procesar: "; // Solicita la cantidad de ángulos
    cin >> n; // Lee la cantidad de ángulos
    system("cls"); // Limpia la pantalla de la consola

    funcion(n); // Llama a la función para ingresar, convertir y calcular cuadrantes
    mostrar(n); // Llama a la función para mostrar los resultados

    return 0; // Finaliza el programa
}

/**
 * @brief Función para ingresar ángulos en radianes, convertirlos a sexagesimales
 * y determinar su cuadrante.
 * @param n Cantidad de ángulos a procesar.
 */
void funcion(int n)
{
    int i; // Contador para los bucles
    // 'a', 'd' son temporales para grados y minutos. 'f' almacena grados normalizados para cuadrante.
    int a, d, f[100];
    // 'b', 'c', 'e' son temporales para cálculos de minutos y segundos.
    float b, c, e;

    // Primer bucle: Ingreso de radianes y conversión a grados, minutos, segundos
    for (i = 0; i < n; i++) // Itera 'n' veces para cada ángulo
    {
        cout << "Ingrese el ángulo en radianes para el elemento " << i + 1 << ": "; // Solicita el ángulo
        cin >> lista[i].rad; // Lee el ángulo en radianes
        system("cls"); // Limpia la pantalla

        // Conversión de radianes a grados sexagesimales
        // Se utiliza M_PI de <cmath> para una mayor precisión de PI
        double total_degrees = lista[i].rad * 180.0 / M_PI;

        lista[i].grad = static_cast<int>(total_degrees); // Parte entera de los grados

        double minutes_float = (total_degrees - lista[i].grad) * 60.0; // Parte decimal de los grados convertida a minutos
        lista[i].min = static_cast<int>(minutes_float); // Parte entera de los minutos

        lista[i].seg = (minutes_float - lista[i].min) * 60.0; // Parte decimal de los minutos convertida a segundos
    }

    // Segundo bucle: Normalización de los grados para la determinación del cuadrante
    // Se asegura que el ángulo esté en el rango [0, 360)
    for (i = 0; i < n; i++)
    {
        int temp_grad = lista[i].grad; // Copia los grados para normalización

        // Normaliza el ángulo para que esté entre 0 y 359 grados
        while (temp_grad >= 360)
        {
            temp_grad -= 360;
        }
        while (temp_grad < 0)
        {
            temp_grad += 360;
        }
        f[i] = temp_grad; // Almacena el ángulo normalizado en el arreglo 'f'
    }

    // Tercer bucle: Determinación del cuadrante
    for (i = 0; i < n; i++)
    {
        if (f[i] > 0 && f[i] < 90) // Primer cuadrante (0° < ángulo < 90°)
        {
            strcpy(lista[i].cuad, "Primer Cuadrante");
        }
        else if (f[i] > 90 && f[i] < 180) // Segundo cuadrante (90° < ángulo < 180°)
        {
            strcpy(lista[i].cuad, "Segundo Cuadrante");
        }
        else if (f[i] > 180 && f[i] < 270) // Tercer cuadrante (180° < ángulo < 270°)
        {
            strcpy(lista[i].cuad, "Tercer Cuadrante");
        }
        else if (f[i] > 270 && f[i] < 360) // Cuarto cuadrante (270° < ángulo < 360°)
        {
            strcpy(lista[i].cuad, "Cuarto Cuadrante");
        }
        else if (f[i] == 0 || f[i] == 90 || f[i] == 180 || f[i] == 270 || f[i] == 360) // Ángulos en los ejes
        {
            strcpy(lista[i].cuad, "Eje Cuadrantal"); // Se usa "Eje Cuadrantal" para mayor precisión
        }
        else
        {
            strcpy(lista[i].cuad, "Indefinido"); // Caso por si el ángulo no cae en ninguna categoría (ej. error de cálculo)
        }
    }
}

/**
 * @brief Función para mostrar el contenido de la tabla de ángulos.
 * @param n Cantidad de ángulos a mostrar.
 */
void mostrar(int n)
{
    int i; // Contador para el bucle
    system("cls"); // Limpia la pantalla

    cout << "--- Contenido de la Tabla de Ángulos ---" << endl; // Encabezado de la tabla
    cout << fixed << setprecision(2); // Configura la salida de flotantes a 2 decimales

    // Itera sobre cada ángulo en la tabla y muestra sus detalles
    for (i = 0; i < n; i++)
    {
        cout << "\n--- Ángulo " << i + 1 << " ---" << endl;
        cout << "  Ángulo en Radianes: " << lista[i].rad << " rad" << endl;
        cout << "  Grados:             " << lista[i].grad << "°" << endl;
        cout << "  Minutos:            " << lista[i].min << "'" << endl;
        cout << "  Segundos:           " << lista[i].seg << "\"" << endl;
        cout << "  Cuadrante:          " << lista[i].cuad << endl;
    }
    cout << "\n----------------------------------------" << endl;
}

90&&f[i]>=360&&lista[i].grad>