Practica 1

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>       /* clock_t, clock, CLOCKS_PER_SEC */
#include <math.h>       /* sqrt */
#include <windows.h>

int *numeros;

void readi(int *vector, int n, char *nombre){
    char temp[19];
    char aux;
    int cont = 0;
    FILE *f;
    f = fopen(nombre, "r");
    if(f == NULL){
        printf("No se ha podido abrir el fichero");
        exit(1);
    }
    while(feof(f) == 0){
        fgets(temp, 19, f);
        *(vector + cont) = atoi(temp);
        cont++;
    }
    fclose(f);
}

void readf(float *fvector, int n, char *nombre){
    char temp[19];
    int cont = 0;
    FILE *f;
    f = fopen(nombre, "r");
    if(f == NULL){
        printf("No se ha podido abrir el fichero");
        exit(1);
    }
    while(feof(f) == 0){
        fgets(temp, 30, f);
        fvector[cont] = atof(temp);
        cont++;
    }
    fclose(f);
}

void
merge (int *A, int a, int *B, int b, int *C)
{
  int i,j,k;
  i = 0;
  j = 0;
  k = 0;
  while (i < a && j < b) {
    if (A[i] <= B[j]) {
      /* copy A[i] to C[k] and move the pointer i and k forward */
      C[k] = A[i];
      i++;
      k++;
    }
    else {
      /* copy B[j] to C[k] and move the pointer j and k forward */
      C[k] = B[j];
      j++;
      k++;
    }
  }
  /* move the remaining elements in A into C */
  while (i < a){
    C[k]= A[i];
    i++;
    k++;
  }
  /* move the remaining elements in B into C */
  while (j < b){
    C[k]= B[j];
    j++;
    k++;
  }
}

/**
 * merge_sort()
 * Sort array A with n integers, using merge-sort algorithm.
 **/
void
merge_sort(int *A, int n) {
  int i;
  int *A1, *A2;
  int n1, n2;

  if (n < 2)
    return;   /* the array is sorted when n=1.*/

  /* divide A into two array A1 and A2 */
  n1 = n / 2;   /* the number of elements in A1 */
  n2 = n - n1;  /* the number of elements in A2 */
  A1 = (int*)malloc(sizeof(int) * n1);
  A2 = (int*)malloc(sizeof(int) * n2);

  /* move the first n/2 elements to A1 */
  for (i =0; i < n1; i++) {
    A1[i] = A[i];
  }
  /* move the rest to A2 */
  for (i = 0; i < n2; i++) {
    A2[i] = A[i+n1];
  }
  /* recursive call */
  merge_sort(A1, n1);
  merge_sort(A2, n2);

  /* conquer */
  merge(A1, n1, A2, n2, A);
  free(A1);
  free(A2);
}

int main(){
    int n = 1000;
    int *vector;
    int i;
    vector = (int*)malloc(n * sizeof(int));
    LARGE_INTEGER start1, start2, start3, start4, start5, start6, start7, start8, start9,
                    end1, end2, end3, end4, end5, end6, end7, end8, end9;
    LARGE_INTEGER perfFrequency;
    double secs;
    float var;

    if(vector == NULL){
        printf("No se ha podido reservar memoria.");
    }else{
        readi(vector, n, "Ordenar.txt");
        if (QueryPerformanceFrequency(&perfFrequency) == 0 || perfFrequency.QuadPart == 0L){
            perror("Error in QueryPerformanceFrequency()");
            exit(EXIT_FAILURE);
        }
        QueryPerformanceCounter(&start1);
        merge_sort(vector, n);
        QueryPerformanceCounter(&end1);
        secs = end1.QuadPart - start1.QuadPart;
        secs = 1000000000*secs/perfFrequency.QuadPart;
        printf("La tarea de ordenamiento de mil enteros ha tardado %lf nanosegundos\n", secs);
    }

    n = 10000000;
    int *vector10;
    vector10 = (int*)malloc(n * sizeof(int));

    if(vector10 == NULL){
        printf("No se ha podido reservar memoria.");
    }else{
        readi(vector10, n, "ordenar10m.txt");
        if (QueryPerformanceFrequency(&perfFrequency) == 0 || perfFrequency.QuadPart == 0L){
            perror("Error in QueryPerformanceFrequency()");
            exit(EXIT_FAILURE);
        }
        QueryPerformanceCounter(&start2);
        merge_sort(vector10, n);
        QueryPerformanceCounter(&end2);
        secs = end2.QuadPart - start2.QuadPart;
        secs = 1000000000*secs/perfFrequency.QuadPart;
        printf("La tarea de ordenamiento de diez mil enteros ha tardado %lf nanosegundos\n", secs);
    }

    long val;
    int *vectorop;
    vectorop = (int*)malloc(n*sizeof(int));
    readi(vectorop, n, "op.txt");
    if (QueryPerformanceFrequency(&perfFrequency) == 0 || perfFrequency.QuadPart == 0L){
            perror("Error in QueryPerformanceFrequency()");
            exit(EXIT_FAILURE);
        }
    QueryPerformanceCounter(&start3);
    for(i = 0; i < n - 1; i++){
        val = vectorop[i]+vector10[i + 1];
    }
    QueryPerformanceCounter(&end3);
    secs = end3.QuadPart - start3.QuadPart;
    secs = 1000000000*secs/perfFrequency.QuadPart;
    printf("La tarea de suma de enteros ha tardado %lf nanosegundos\n", secs);

    if (QueryPerformanceFrequency(&perfFrequency) == 0 || perfFrequency.QuadPart == 0L){
            perror("Error in QueryPerformanceFrequency()");
            exit(EXIT_FAILURE);
        }
    QueryPerformanceCounter(&start4);
    for(i = 0; i < n - 1; i++){
        val = vectorop[i]-vector10[i + 1];
    }
    QueryPerformanceCounter(&end4);
    secs = end4.QuadPart - start4.QuadPart;
    secs = 1000000000*secs/perfFrequency.QuadPart;
    printf("La tarea de resta de enteros ha tardado %lf nanosegundos\n", secs);

    if (QueryPerformanceFrequency(&perfFrequency) == 0 || perfFrequency.QuadPart == 0L){
            perror("Error in QueryPerformanceFrequency()");
            exit(EXIT_FAILURE);
        }
    QueryPerformanceCounter(&start5);
    for(i = 0; i < n - 1; i++){
        val = vectorop[i]*vector10[i + 1];
    }
    QueryPerformanceCounter(&end5);
    secs = end5.QuadPart - start5.QuadPart;
    secs = 1000000000*secs/perfFrequency.QuadPart;
    printf("La tarea de multiplicación de enteros ha tardado %lf nanosegundos\n", secs);

    double vald;
    if (QueryPerformanceFrequency(&perfFrequency) == 0 || perfFrequency.QuadPart == 0L){
            perror("Error in QueryPerformanceFrequency()");
            exit(EXIT_FAILURE);
        }
    QueryPerformanceCounter(&start6);
    for(i = 0; i < n - 1; i++){
        vald = vectorop[i]/vector10[i + 1];
    }
    QueryPerformanceCounter(&end6);
    secs = end6.QuadPart - start6.QuadPart;
    secs = 1000000000*secs/perfFrequency.QuadPart;
    printf("La tarea de división de enteros ha tardado %lf nanosegundos\n", secs);

    n = 10000000;
    float *fvector;
    fvector = (float*)malloc(n * sizeof(float));

    if(fvector == NULL){
        printf("No se ha podido reservar memoria.");
    }else{
        readf(fvector, n, "fop.txt");
        if (QueryPerformanceFrequency(&perfFrequency) == 0 || perfFrequency.QuadPart == 0L){
            perror("Error in QueryPerformanceFrequency()");
            exit(EXIT_FAILURE);
        }
        QueryPerformanceCounter(&start7);
        for(i = 0; i < n - 1; i++){
            var = fvector[i]+fvector[i + 1];
        }
        QueryPerformanceCounter(&end7);
        secs = end7.QuadPart - start7.QuadPart;
        secs = 1000000000*secs/perfFrequency.QuadPart;
        printf("La tarea de suma de reales ha tardado %lf nanosegundos\n", secs);

        if (QueryPerformanceFrequency(&perfFrequency) == 0 || perfFrequency.QuadPart == 0L){
            perror("Error in QueryPerformanceFrequency()");
            exit(EXIT_FAILURE);
        }
        QueryPerformanceCounter(&start8);
        for(i = 0; i < n - 1; i++){
            var = fvector[i]-fvector[i + 1];
        }
        QueryPerformanceCounter(&end8);
        secs = end8.QuadPart - start8.QuadPart;
        secs = 1000000000*secs/perfFrequency.QuadPart;
        printf("La tarea de resta de reales ha tardado %lf nanosegundos\n", secs);

        LARGE_INTEGER start10, end10;
        LARGE_INTEGER perfFrequency1;
        double secs1;
        if (QueryPerformanceFrequency(&perfFrequency1) == 0 || perfFrequency1.QuadPart == 0L)
        {
        perror("Error in QueryPerformanceFrequency()");
        exit(EXIT_FAILURE);
        }
        QueryPerformanceCounter(&start10);

        for(i = 0; i < n - 1; i++){
            var = fvector[i]*fvector[i + 1];
        }
        QueryPerformanceCounter(&end10);
        secs = end10.QuadPart - start10.QuadPart;
        secs = 1000000000*secs/perfFrequency.QuadPart;
        printf("La tarea de multiplicación de reales ha tardado %lf nanosegundos\n", secs);

        if (QueryPerformanceFrequency(&perfFrequency) == 0 || perfFrequency.QuadPart == 0L){
            perror("Error in QueryPerformanceFrequency()");
            exit(EXIT_FAILURE);
        }
        QueryPerformanceCounter(&start1);
        for(i = 0; i < n - 1; i++){
            var = fvector[i]/fvector[i + 1];
        }
        QueryPerformanceCounter(&end1);
        secs = end1.QuadPart - start1.QuadPart;
        secs = 1000000000*secs/perfFrequency.QuadPart;
        printf("La tarea de división de reales ha tardado %lf nanosegundos\n", secs);
    }

    system("pause");
    return 0;
}

//http://www.cs.cityu.edu.hk/~lwang/ccs4335/mergesort.c
//http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C/Manejo_de_archivos