/***********************************************************************
 * Soluciones propuestas para resolver el examen de ATDI del día 171207* 
 * Francisco Javier Garcia Castellano 2008                             *
 ***********************************************************************/

/***********************************************************************/ 
//BIBLOTECAS
#include <stdio.h>
#include <math.h>


/***********************************************************************/ 
//CONSTANTES
#define MAX 50 //Maximo tamaño para vectores 


/***********************************************************************/ 
//FUNCIONES

/*---------------------------------------------------------------------*/
/** Procedimiento que multiplica dos matrices.
Parámetros:
matriz1: primera matriz de números reales. 
filas1: número de filas de la primera matriz.
columnas1: número de columnas de la primera matriz.
matriz2: segunda matriz de números reales. 
filas2: número de filas de la segunda matriz.
columnas2: número de columnas de la segunda matriz.
resultado: matriz donde se guarda la multiplicación de matriz1 por matriz2.
*/
void multiplica (double matriz1[50][50],int filas1, int columnas1, double matriz2[50][50],int filas2, int columnas2, double resultado[50][50]) {

  int i,j,k; /*Iteradores*/

/*Primero miramosi ss podemos multiplicar las matrices*/
  if (columnas1!=filas2)
    printf ("ERROR: No se puede multiplicar las matrices");
  else
   for (i=0;i<filas1;i=i+1) 
     for (j=0;j<columnas2;j=j+1) {
       resultado[i][j]=0;/*Inicializamos el elemento i,j del resultado a 0*/
       for (k=0;k<columnas1;k=k+1)
	resultado[i][j]=resultado[i][j]+matriz1[i][k]*matriz2[k][j];
     }
}/*Fin función multiplica*/

/*---------------------------------------------------------------------*/
/** Función main para el ejercicio que calcula la raiz cuadrada de un 
número n mediante el algoritmo de Newton que  se basa en aproximaciones 
sucesivas, donde la primera aproximación  de la raíz de un  número N es: 
                 X1 = N/2
Y las siguientes: 
                 Xi+1 =  Xi /2  +  N/(2*Xi)
*/
int main_raiz(){
  int precision=0; /*Número de aproximaciones que vamos a hacer*/
  int i; /*iterador*/
  double n; /*Número del cual queremos calcular la raíz cuadarda*/
  double xi;/*Aproximación i-ésima*/

  printf("Dame el numero para calcular su raiz cuadrada:");
  scanf("%lf",&n);
 
  printf("Dame el numero de iteraciones (aproximaciones) a dar:");
  scanf("%d",&precision);

  /*Calculamos la primera aproximación*/
  xi=n/2;

  /*Calculamos la raiz con la precisión dada*/
  for (i=0;i<precision;i=i+1)
    xi=(xi/2)+n/(2*xi);

  /*Mostramos los resultados obtenidos*/
  printf("La raiz aproximada de %lf con %d iteraciones es= %lf",n,precision,xi);

  return 0;
}/*Fin main raiz cuadrada aproximada por Newton*/

/*---------------------------------------------------------------------*/

/*Procedimiento que muestra el vector.
Parámetros:
vector: vector con los datos.
n: tamaño del vector.*/
void muestra(double vector[], int n) {
  int i; /*Iterador*/

  /*Mostramos cada uno de los elementos del vector*/
  for (i=0;i<n;i=i+1) 
    printf ("%lf ",vector[i]);
  
}/*Fin procedimiento muestra vector*/

/*---------------------------------------------------------------------*/
/*Procedimiento que ordena un vector.
Parámetros:
vector: vector con los datos.
n: tamaño del vector.*/
void ordena(double vector[], int n) {
  int i, j; /*Iteradores*/
  int cambio=1; /*Indica si ha habido alguna modificación en la ordenación*/
  double tmp; /*Var. auxiliar para intercambiar variables*/

  /*Ordenación por intercambio directo: burbuja modificada*/
  for (i=0; (i<n) && (cambio); i++) {
    cambio=0; /*Suponemos que todo está ordenado*/
    for (j=n-1; j>i; j--)
      if (vector[j] < vector[j-1]) {
        tmp = vector[j];
        vector[j] = vector[j-1];
        vector[j-1] = tmp;
	cambio=1;/*Si ha habido un cambio, sigue desordenado*/
    }
  }


}/*Fin procedimiento que ordena un vector*/
/*---------------------------------------------------------------------*/
/*Procedimiento que calcula la suma de dos vectores y lo guarda en un tercero.
Parámetros:
vector1: Primer vector con los datos.
vector2: Segundo vector con los datos.
suma: Vector con la suma de los datos.
n: tamaño de los vectores.*/
void sumar(double vector1[], double vector2[], double suma[], int n){
  int i; /*Iterador*/

  /*Recorremos y sumamos cada uno de los elementos de los vectores*/
  for (i=0;i<n;i=i+1) 
    suma[i]=vector1[i]+vector2[i];
  
}/*Fin procedimiento suma vectores*/

/*---------------------------------------------------------------------*/
/*---------------------------------------------------------------------*/
int main(){
  double vector1[MAX]; /*Variable donde guardamos los datos del primer vector*/
  double vector2[MAX]; /*Variable donde guardamos los datos del segundo vector*/
  double suma[MAX]; /*Variable donde guardamos los suma de los vecores*/
  int i;/*Iterador*/
  int n; /*Tamaño de los vectores*/
  int opcion; /*Opción escogida del menú*/


  /*Matrices de ejemplo para el ejercicio de multiplicación de matrices*/
  double matrizA[MAX][MAX]={{ 1, -2, 11},
                            { 1,  0, -7}  };
  double matrizB[MAX][MAX]={{ -2,  10},
                            {  1,  -1},
                            { -1, -23}};
  double matrizM[MAX][MAX];
  int j;

  /*Pedimos el tamaño de los vectores*/
  do{
    printf ("Dame el tamaño de los vectores:");
    scanf("%d",&n);
  }while  ((n<1) || (n>MAX));

  /*Leemos los datos del primer vector*/
  for (i=0;i<n;i++) {
    printf ("\nDame el valor %d del primer vector:",i);
    scanf("%lf",&(vector1[i]) );
  }

  /*Leemos los datos del segundo vector*/
  for (i=0;i<n;i++) {
    printf ("\nDame el valor %d del segundo vector:",i);
    scanf("%lf",&(vector2[i]) );
  }
  

  /*MENU*/
  do{
    /*Mostramos el menú*/
    printf("\n----------MENU---------------\n");
    printf("\n1 Mostrar Vectores\n");
    printf("2 Mostrar Suma \n");
    printf("3 Ordenar primer vector\n");
    printf("4 Ordenar segundo vector\n");
    printf("5 Salir\n");
    printf("Opción:");

    /*Leemos la opción del usuario*/
    scanf("%d",&opcion);
    printf("\n");
   
    /*Dependiendo de la opción escogida efectuamos una opción u otra*/
    switch (opcion) {
      /*Primera opción: Mostrar vectores*/
      case 1: 
	printf("\nLos vectores son::\n");
	muestra(vector1,n);
	printf("\n");
	muestra(vector2,n);
	break;

      /*Segunda opción: Calcular la suma  y mostrarla*/
      case 2: 
	sumar(vector1,vector2,suma,n);
	printf("\n La suma es:\n");
	muestra(suma, n);
	printf("\n");
	break;
	
      /*Tercera opción: Ordenar primer vector*/
      case 3:
	ordena(vector1,n);
	printf("\nEl vector después de la ordenación queda:");
        muestra(vector1,n);
	printf("\n");
	break;

      /*cuarta opción: Ordenar segundo vector*/
      case 4: 
	ordena(vector2,n);
	printf("\nEl vector después de la ordenación queda:");
        muestra(vector2,n);
	printf("\n");
	break;

      /*Quinta opción: salir*/
      case 5: 
	break;

      /*En otro caso es opción no válida*/
      default:
	printf("Opción Inválida\n");
     
    }/*Fin switch*/

  } while (opcion!=5);

  /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
  /*Trozo para probar el ejercicio de la multiplicación de vectores*/
  multiplica (matrizA,2,3,matrizB,3,2,matrizM);
  for (i=0;i<2;i++) {
    for (j=0;j<2;j++)
      printf("%0.1lf ",matrizM[i][j]);
    printf("\n");
  }
  
  /*++++++++++++++++++++++++++++++++++++++++++++++++++*/ 
  /*Trozo para probar el ejercicio de la raiz cuadrada*/
  main_raiz();
  printf("\n");

  /*Terminamos*/
  return 0;
}
/*---------------------------------------------------------------------*/