Tipo de Dato Abstracto

1. Implemente el TDA punto para un punto en \(\mathbb{R}^2\). Utilice, como representación interna, la siguiente definición:

   struct punto {
       double x;
       double y;
   };
   

   Implemente además las siguientes primitivas:

   1. punto_t * punto_crear(double, double);

   2. void punto_destruir(punto_t *);

   3. punto_t * punto_copiar(punto_t *, const punto_t *);

   4. punto_t * punto_clonar(const punto_t *);

   5. double punto_get_x(const punto_t *);

   6. double punto_get_y(const punto_t *);

   7. double punto_set_x(punto_t *, double);

   8. double punto_set_y(punto_t *, double);

   9. punto_t * punto_sumar(punto_t *, const punto_t *);

   10. punto_t * punto_restar(punto_t *, const punto_t *);

   11. double punto_distancia(const punto_t *, const punto_t *);

   12. double punto_norma(const punto_t *);

2. Implemente el TDA complejo, con las siguientes primitivas:

   1. complejo_t * complejo_crear(double, double);

   2. void complejo_destruir(complejo_t *);

   3. complejo_t * complejo_copiar(complejo_t *, const complejo_t *);

   4. complejo_t * complejo_clonar(const complejo_t *);

   5. double complejo_get_real(const complejo_t *);

   6. double complejo_get_imag(const complejo_t *);

   7. double complejo_set_real(complejo_t *, double);

   8. double complejo_set_imag(complejo_t *, double);

   9. complejo_t * complejo_conjugar(complejo_t *);

3. Implemente el TDA cadena, con las siguientes primitivas:

   1. cadena_t * cadena_crear(const char *);

   2. void cadena_destruir(cadena_t *);

   3. cadena_t * cadena_copiar(cadena_t *, const cadena_t *);

   4. cadena_t * cadena_clonar(const cadena_t *);

   5. cadena_t * cadena_concatenar(cadena_t *, const cadena_t *);

   6. cadena_t * cadena_strcpy(cadena_t *, const char *);

   7. cadena_t * cadena_strcat(cadena_t *, const char *);

4. Implemente el TDA matriz de flotantes en \(\mathbb{R}^{F\times C}\), con las siguientes primitivas:

   1. matriz_t *matriz_crear(size_t filas, size_t columnas);

   2. void matriz_destruir(matriz_t *);

   3. bool matriz_guardar(matriz_t *, size_t fila, size_t columna, float valor);

   4. bool matriz_obtener(const matriz_t *, size_t fila, size_t columna, float *valor);

   5. void matriz_dimensiones(const matriz_t *, size_t *filas, size_t *columnas);

   6. float matriz_traza(const matriz_t *);

   7. matriz_t *matriz_transponer(const matriz_t *);

   8. matriz_t *matriz_con_columna(const matriz_t *, const float *vector, size_t columna); que dado un vector con largo igual alto de la matriz devuelva una nueva matriz con el vector reemplazando la columna indicada.

   9. matriz_t *matriz_sumar(const matriz_t *, const matriz_t *);

   10. matriz_t *matriz_multiplicar(const matriz_t *, const matriz_t *);

   11. matriz_t *matriz_menor(const matriz_t *, size_t fila, size_t columna); que devuelva una matriz nueva sin la fila y la columna dadas.

   12. (Si ya resolviste el ejercicio 11 de la guía de recursividad) float *matriz_resolver(const matriz_t *A, const float *b); que resuelva un sistema \(Ax=b\) utilizando la regla de Cramer, se debe devolver el vector \(x\). (Utilizar la función del inciso h y la función determinante.)

5. Implemente el TDA vector, con cada elemento del vector como puntero void. Utilice la siguiente representación:

   struct vector {
       size_t largo;
       void ** datos;
   };
   

6. Implemente el TDA vector, utilizando bloques de memoria para almacenar los datos. Utilice la siguiente representación:

   struct vector {
       size_t largo;
       size_t tam_elem;
       unsigned char * array;
   };
   

7. Implemente el TDA lista, en sus versiones iterativa y recursiva.

   struct nodo {
       struct nodo * next;
       void * data;
   };
   

8. Implemente un TDA contenedor que admita únicamente insertar y eliminar elementos al principio. Este tipo de contenedores representa un stack.