Mostrando entradas con la etiqueta # C. Mostrar todas las entradas
Mostrando entradas con la etiqueta # C. Mostrar todas las entradas

sábado, 4 de junio de 2016

Método de Jacobi de resolución de sistemas programado en C/C++

Método de Jacobi programado en C/C++ para la resolución de sistemas lineares de ecuaciones:

El método Jacobi es el método iterativo para resolver sistemas de ecuaciones lineales más simple y se aplica sólo a sistemas cuadrados, es decir a sistemas con tantas incógnitas como ecuaciones, del tipo:
                                                                   Ax=b

Idea:
1-Separar la matriz A en su diagonal (D) y en su matrices estrictamente superior (U) e inferior (L):
                                                                  A=D+L+U=D+R
2-Reescribir el sistema con este desarrollo de la matriz A:
                                                                  b-(D+R)x=0
                                                                  b-Rx=Dx
                                                                  D^(-1)(b-Rx)=x
3- A partir de esta ultima expresion se itera tomando un valor inicial de x denominado x0:
                                                                  D^(-1)(b-Rx(i))=x(i+1)
donde x(i) hace referencia al valor de x en la iteración i.
Hay que notar que la complejidad de calcular la inversa de la matriz diagonal es nula:
                                                                 D^(-1)(i,i)=1/D^(-1)(i,i)

Nota: El método de Jacobi siempre converge si la matriz A es estrictamente diagonal dominante y puede converger incluso si esta condición no se satisface.

Dejo aquí los enlaces a otros metodos de resolucion de sistemas programados en C y en PASCAL:

JACOBI en PASCAL: http://cypascal.blogspot.fr/2012/03/resolucion-de-sistemas-mediante-jacobi.html
GAUSS en C: http://cypascal.blogspot.fr/2012/10/metodo-de-gauss-en-cc.html
GAUSS en PASCAL: http://cypascal.blogspot.fr/2012/10/metodo-de-gauss-en-cc.html
LU en PASCAL:http://cypascal.blogspot.fr/2012/02/factorizacion-lu.html

Código:

#include <stdio.h>
#include <stdlib.h>

int dim;
float norma(float vector1[],float vector2[]);
float suma_jacobi(float Matriz[], float vector[], int componente);

int main(){
    int i,j,iteraciones=0;
    float error,epsilon;
    printf("\n METODO DE JACOBI DE RESOLUCION DE SISTEMAS Ax=b \n");

    printf("Dimension de la matriz A: ");
    scanf("%d",&dim);
    float A[dim][dim],b[dim],x[dim],x_prev[dim],aux[dim];

    printf("\n Elementos de la matriz A: \n");
    for(i=0;i<dim;i++) for(j=0;j<dim;j++){
        printf("A(%d,%d)=",i,j); scanf("%f",&A[i][j]);
    }

    printf("\n Elementos del vector b: \n");
    for(i=0;i<dim;i++){
        printf("b(%d)=",i); scanf("%f",&b[i]);
    }

    printf("\n Error de parada: \n");
    printf("E=",i); scanf("%f",&epsilon);
    error=epsilon+1;

    //cominezo algoritmo de Jacobi
    //Error se mide como la norma del vector diferenceia entre la iteracion i e i+1
    printf("\n Valor inicail de la iteracion: \n");
    for(i=0;i<dim;i++){
        printf("x0(%d)=",i); scanf("%f",&x_prev[i]);
    }
    while (error>epsilon){
        for(i=0;i<dim;i++){
            for(j=0;j<dim;j++) aux[j]=A[i][j];
            x[i]=(1/A[i][i])*(b[i]-suma_jacobi(aux,x_prev,i));
        }
        error=norma(x,x_prev);

        printf("\n\n Iteracion %d: \n",iteraciones);
        for(i=0;i<dim;i++){
            x_prev[i]=x[i];
            printf("X(%d)=%f \n",i,x[i]);
        }

        iteraciones++;
        if (iteraciones==10) error=epsilon-1;
    }

    printf("Solucion del sistema\n");
    printf("Numero de iteraciones: %d \n", iteraciones);
    for(i=0;i<dim;i++){
        printf("x(%d)=%f\n",i,x[i]);
    }
    return 1;
}

float norma(float vector1[],float vector2[]){
    float aux=0;
    int i;
    for(i=0;i<dim;i++){
        aux=aux+(vector1[i]-vector2[i])*(vector1[i]-vector2[i]);
    }
    return aux;
}

float suma_jacobi(float Matriz[], float vector[], int componente)
{
    float aux=0;
    int i;
    for(i=0;i<dim;i++){
        if (componente!=i){
            aux=aux+Matriz[i]*vector[i];
        }
    }
    return aux;
}


Salu10

martes, 17 de mayo de 2016

Método de agrupamiento K-Means en Lenguaje C

El siguiente programa escrito en C genera una segmentacion de un conjunto de vectores segun le metodo de las K-Means.
Dada una familia de n vectores {v_1,v_2...v_n} el método de agrupamiento K-means permite agruparlos en un número k determinado de grupos {S_1,S_2...S_k}, de manera que se minimice la suma de los errores cuadraticos de cada vector respecto al punto medio de todos los vectores del mismo grupo al que pertenece.
Este método es utilizado para la compresión de imágenes en tratamiento de señal, así como para la explotación de datos en lo que concierne al data mining y big data. Es un método bastante sencillo pero que consigue unos buenos resultados. Si necesitan más información sobre este método una búsqueda rápida les puede solucionar las dudas. Si es algo del código, encantado de ayudarles mediante un comentario en este post.

El fichero de entrada que contiene los vectores a ordenar debe ser del tipo (por defecto este fichero se llama "datos.txt"):

0.5 -2 3 4
1 2.4 -1.2 0
1 2.9 4 2
0.1 0.002 -3.14 5
6.1 -5.1 -6.4 7
9.9 7 -2.4 3
-8 1 0.1 -3
0.03 -5 2.9 6

Donde cada fila representa un vector (un total de ocho en este caso), y cada columna una componente de ese vector (4 en este caso).

El fichero de salida que se obtiene es:

  SALIDA DEL METODO KMEANS

KMeans ha generado los siguientes grupos: 
- Grupo 0 con media: [ -8.000000  1.000000  0.100000  -3.000000 ]
- Grupo 1 con media: [ 0.526000  -0.339600  1.112000  3.400000 ]
- Grupo 2 con media: [ 8.000000  0.950000  -4.400000  5.000000 ]


KMeans ha generado los siguientes grupos: 
0.500000 -2.000000 3.000000 4.000000 1 
1.000000 2.400000 -1.200000 0.000000 1 
1.000000 2.900000 4.000000 2.000000 1 
0.100000 0.002000 -3.140000 5.000000 1 
6.100000 -5.100000 -6.400000 7.000000 2 
9.900000 7.000000 -2.400000 3.000000 2 
-8.000000 1.000000 0.100000 -3.000000 0 
0.030000 -5.000000 2.900000 6.000000 1 

 Error: 8.097519 

 Reparticion grupos: 
Grupo 0 : 1  elementos. 
Grupo 1 : 5  elementos. 
Grupo 2 : 2  elementos.  


El código escrito en C está suficientemente comentado por lo que no debería suponer ningún problema:




/*Metodo k-means de agrupamiento CYPASCAL.BLOGSPOT.COM*/
/*NOTAS IMPORTANTES:
    - Variables principales:
        Comp: Numero de componenetes que tiene cada vector. Dimensón del espacio vectorial Rn al que
        pertenecen.
        Grup: Numero de conjuntos en los que se van a agrupar los vectores.
        Epsilon: Si la diferencia entre el error cometido en la iteración anterior y el error cometido
        en la iteración actual es menor que este valor, se sale del algoritmo.
    - En el fichero de entrada cada vector aparece en una linea, y cada componente separada por un espacio.
    A modo de ejemplo, si el numero de componentes es 3, y el numero de vectores a ordenar es 5, un fichero
    tipo podría ser:

    0.25 21.2 -1.25
    14.3 -1.2 5
    -0.001 10 0
    0 -1.5 4
    1 2 7
*/

#include <stdio.h>
#include <stdlib.h>

FILE *Lectura, *Escritura;
int Comp,Vect,Grup;
float Epsilon;

float Norma(float Vect1[], float Vect2[]);

int main(void)
{
    /* 1: Pedimos los datos necesarios */
    srand(time(NULL));
    printf("METODO K-MEANS (Agrupamiento de vectores minimizando el ECM) \n");
    printf("Numero de componentes del vector: ");
    scanf("%i", &Comp);
    printf("Numero de vectores a ordenar: ");
    scanf("%i", &Vect);
    printf("Numero de conjuntos en los que agrupar los vectores: ");
    scanf("%i", &Grup);
    printf("Limite de convergencia: ");
    scanf("%f", &Epsilon);

    int aVect=0,aComp=0,i,j,minG;
    float Tabla[Vect][Comp];
    float min,aux,ErrorAct,ErrorAnt=0,dif;
    float MediaGrup[Grup][Comp],maxi[Comp],mini[Comp];
    for (i=0; i<Comp; i++){maxi[i]=0; mini[i]=0;}
    int CompGrup[Vect]; //Grupo en el que se encuentra el vector
    int NumCompGrup[Grup]; //Numero de componentes en cada grupo

    /* 2: Leemos el fichero de lectura y cargamos los datos en la tabla para un acceso más rápido*/
    Lectura=fopen("datos.txt","r");
    if (Lectura) {
        for (i=0; i<Vect; i++) for (j=0; j<Comp; j++) {{
            fscanf(Lectura,"%f",&Tabla[i][j]);
            if (mini[j] > Tabla[i][j]) mini[j] = Tabla[i][j];
            if (maxi[j] < Tabla[i][j]) maxi[j] = Tabla[i][j];
            if (Tabla[i][j]==EOF){
                i=Vect;
                j=Comp;}
            printf("%f \n",Tabla[i][j]);
        }}
        fclose(Lectura);
    }

    /* 3: Inicializamos el vector de medias con valores aleatorios*/
    for (i=0; i<Grup; i++) for (j=0; j<Comp; j++) {
        MediaGrup[i][j]=(float)rand()/RAND_MAX*(maxi[j]-mini[j])+mini[j];
    }

    dif=Epsilon+1; //Para entrar en el bucle
    /* 4: Bucle principal del que no se sale hasta ser inferior a epsilon*/
    while (dif>Epsilon){
        ErrorAct=0;
        /* 4.1: Se mira a que grupo pertenece cada vector*/
        for (i=0; i<Vect; i++){
            min = Norma(Tabla[i],MediaGrup[0]);
            minG=0;
            for (j=1; j<Grup; j++){
                aux=Norma(Tabla[i],MediaGrup[j]);
                if (aux<min){min=aux; minG=j;}
            }
            CompGrup[i]=minG;
            ErrorAct=ErrorAct+min;
        }

        /* 4.2: Se actualiza el valor de la media del grupo*/
        for (i=0; i<Grup; i++){
            for (j=0; j<Comp; j++){
                MediaGrup[i][j]=0;
            }
            NumCompGrup[i]=0;
        }
        for (i=0; i<Vect; i++){
            for (j=0; j<Comp; j++){
                MediaGrup[CompGrup[i]][j]=MediaGrup[CompGrup[i]][j]+Tabla[i][j];
            }
            NumCompGrup[CompGrup[i]]++;
        }
        for (i=0; i<Grup; i++){
            for (j=0; j<Comp; j++){
                MediaGrup[i][j]=MediaGrup[i][j]/NumCompGrup[i];
            }
        }
        dif=abs(ErrorAct-ErrorAnt);
        ErrorAnt=ErrorAct;
    }

    /* 5: Escritura de los resultados finales*/
    Escritura=fopen("SalidaKMEANS.txt","w");
    fprintf(Escritura, "\n SALIDA DEL METODO KMEANS\n\n");
    fprintf(Escritura, "KMeans ha generado los siguientes grupos: \n");
    for (i=0; i<Grup; i++){
        fprintf(Escritura, "- Grupo %i con media: [",i);
        for (j=0; j<Comp; j++) fprintf(Escritura, " %f ",MediaGrup[i][j]);
        fprintf(Escritura, "]\n");
    }
    fprintf(Escritura, "\n\nKMeans ha generado los siguientes grupos: \n");
    for (i=0; i<Vect; i++){
        for (j=0; j<Comp; j++){
            fprintf(Escritura, "%f ", Tabla[i][j]);
        }
        fprintf(Escritura, "%i \n", CompGrup[i]);
    }
    fprintf(Escritura, "\n Error: %f \n", ErrorAct);

    fprintf(Escritura, "\n Reparticion grupos: \n");
    for (i=0; i<Grup; i++){
        fprintf(Escritura, "Grupo %i : %i  elementos. \n", i,NumCompGrup[i]);
    }
    fclose(Escritura);
    return 0;
}

float Norma(float Vect1[], float Vect2[])
{
    float aux=0;
    int n,j;
    n = (int) sizeof(Vect1)/sizeof(Vect1[0]);
    for (j=0; j<n; j++) {
        aux=aux+(Vect1[j]-Vect2[j])*(Vect1[j]-Vect2[j]);
    }
    return aux;
}


Salu10.

viernes, 12 de febrero de 2016

Crear una distribución normal en C

En el siguiente programa vamos a estudiar la generación de distribuciones de probabilidad distintas a la uniforme, haciendo uso del comando rand de C. (Aquí la publicación donde se muestra como hacerlo)
C nos permite generar variables aleatorias, sin embargo, estas siguen unicamente una ley de distribución unifrme.  Sin embargo, podemos obtener cualquier otro tipo de distribución, por ejemplo la normal, que es la más ampliamente utilizada, ya que está presente en gran cantidad de fenómenos naturales.
Partiendo del Teorema del limite central, el cual dice:

 "la distribución de probabilidad de la suma de N valores de variables aleatorias Xi independiente pero idénticamente distribuidos, con medias respectivas Ei y variancias sigma^2i, se aproxima asintóticamente a una distribución normal, a medida que N se hace muy grande, y que dicha distribución tiene como media y varianzas respectivamente, a:

"
(Fuente: "Generación de valores de las variables aleatorias", Juan F. Olivares-Pacheco)

Para obtener una distribución normal normalizada (es decir, de media 0 y desviación típica 1) a partir de una uniforme podemos proceder del modo siguiente:
    -1) Generamos N muestras de una señal uniforme, con valores distribuidos entre -0.5 y 0.5, es decir, con p(x)=1, y una esperanza nula.
    -2) Creamos una nueva varible aleatoria, sumando todas las muestras. Esta nueva varaible aleatoria sigue una distribución normal, para grandes valores de N.
    -3) Realizamos estos dos pasos M veces, de modo que podamos verificar que efectivamente se sigue una distribución normal.

El código siguiente, genera una ristra de números que siguen una distribución de media y desviación típica elegidas por el usuario. Los datos se guardan en un fichero de texto.

  /*programa que genera una serie de numeros aleatorios
que siguen una distribución normal, pidiendo al usuario
el número de datos, la varianza y la media de la distribucion,
 y los registra en un fichero .txt*/

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
/*cK define el numero de datos que se suman para obtener
la distribucion normal. Referirse al paper de generacion de
variables aleatorias. Carpeta traitement numerique de signal*/
#define cK 1000

FILE *archivo;
int i,k,dat;
float num, media, var, desv, aux;

int main(void)
{
    /*creamos el archivo de texto*/
    archivo=fopen("prueba.txt","w");

    printf("GENERADOR DISTRIBUCION UNIFORME \n");
    printf("Seleccione la media de la distribucion: ");
    scanf("%f", &media);
    printf("Seleccione la varianza de la distribucion: ");
    scanf("%f", &var);
    printf("Seleccione el numero de datos a crear: ");
    scanf("%i", &dat);

    desv=sqrt(var);
    /*reiniciamos la semilla de generacion de numeros
    aleatorios (srand48 para generar numeros decimales)*/
    srand(time(NULL));
    for (i=1; i<=dat; i++){
        aux=0;
        for (k=1;k<=cK;k++){
            aux=aux+(float)rand()/RAND_MAX;
        }
        num=desv*sqrt((float)12/cK)*(aux-(float)cK/2)+media;
        fprintf(archivo, "%f \n", num);
    }
    fclose (archivo);
    return 0;
}

Salu10

lunes, 10 de noviembre de 2014

Calcula multiplicación de dos matrices en C/C++ (Arrays)

El siguiente programa calcula el producto de dos matrices (arrays bidimensionales), también conocido como producto matricial, en lenguaje de programación C. El programa comprueba que las matrices tienen las dimensiones adecuadas para llevar a cabo el producto de ambas dos. Como programa relacionado coloco el cálculo de la suma de dos matrices:
http://cypascal.blogspot.com.es/2012/07/suma-de-matrices-en-c-arrays.html

Este programa es útil para ver como funcionan los arrays en C.

Aquí les dejo el código del programa multiplicador de matrices:


#include <stdio.h>

int const Tam=101;

void PideDatos(int Dim[][3], float Mat1[][Tam], float Mat2[][Tam]);
void EscribeDatos(int Dim[][3], float Mat[][Tam], int au);
void Mult(int Dim[][3], float Mat1[][Tam], float Mat2[][Tam], float Mat3[][Tam]);


int main(void)
{
 int C, Dimension[4][3];
 float Matriz1[Tam][Tam], Matriz2[Tam][Tam], Matriz3[Tam][Tam];
 PideDatos(Dimension,Matriz1,Matriz2);
 printf("\nCalcula MULTIPLICACION: \n\n");
 EscribeDatos(Dimension,Matriz1,1);
 EscribeDatos(Dimension,Matriz2,2);
 Mult(Dimension,Matriz1,Matriz2,Matriz3);
 printf("\n\n\nLa matriz resultante es: \n");
 EscribeDatos(Dimension,Matriz3,3);
 scanf("%d");
 return(0);
}


void PideDatos(int Dim[][3], float Mat1[][Tam], float Mat2[][Tam])
{
 int A,B,i;
 printf("\n\n ||CALCULA EL PRODUCTO DE MATRICES M1*M2||");

 //Matriz 1
 printf("\n\n\n Introduce el numero de filas de la matriz 1:");
 scanf("%d", &Dim[1][1]);
 printf("\n\n\n Introduce el numero de columnas de la matriz 1:");
 scanf("%d", &Dim[1][2]);
 printf("\n\n INTRODUCIR CADA COMPONENTE DE LA MATRIZ 1:");
 for(A=1;A<= Dim[1][1];A++) for(B=1;B<= Dim[1][2];B++){
printf("\n Termino M1(%d,%d):",A,B); scanf("%f",&Mat1[A][B]);}

 //Matriz 2
 printf("\n\n\n Introduce el numero de filas de la matriz 2:");
 scanf("%d", &Dim[2][1]);
 printf("\n\n\n Introduce el numero de columnas de la matriz 2:");
 scanf("%d", &Dim[2][2]);
 printf("\n\n INTRODUCIR CADA COMPONENTE DE LA MATRIZ 2:");
 for(A=1;A<= Dim[2][1];A++) for(B=1;B<=Dim[2][2];B++){
printf("\n Termino M2(%d,%d):",A,B); scanf("%f",&Mat2[A][B]);}
}



void EscribeDatos(int Dim[][3], float Mat[][Tam], int aux)
{
 int A,B;
 if (aux == 1)
printf("\n\n M1: \n");
 else if (aux == 2)
printf("\n\n M2: \n");
 else
printf("\n\n Resultado: \n");

 for(A=1;A<=Dim[aux][1];A++){
 for(B=1;B<=(Dim[aux][2]);B++)
printf("%7.2f",Mat[A][B]);
 printf("\n");
 }
}

void Mult(int Dim[][3], float Mat1[][Tam], float Mat2[][Tam], float Mat3[][Tam])
{
int A, B, aux;
if (Dim[1][2]==Dim[2][1])
{
Dim[3][1] = Dim[1][1];
Dim[3][2] = Dim[2][2];
for (A = 1; A<= Dim[1][1]; A++){
for (B = 1; B<= Dim[2][2]; B++){
Mat3[A][B] = 0;
for (aux = 1; aux <= Dim[1][2]; aux++)
Mat3[A][B] = Mat3[A][B] + Mat1[A][aux]*Mat2[aux][B];
}
}
}
else
printf("\n\n Las matrices no se puden muiltiplicar \n");

}


Salu10, espero que les sea útil.

miércoles, 22 de mayo de 2013

Método de Gauss para Resolver Sistemas de Ecuaciones en C/C++

Aquí dejo el código para resolver sistemas de ecuaciones mediante Gauss con la pequeña correción, pero importante, comentada en el tema de Método de Gauss:




#include <stdio.h>

void PideDatos(int *Dim, float Sist[][102]);
void EscribeDatos(int Dim, float Sist[][102]);

void ResuelveGauss(int Dim, float Sist[][102]);


int main(void)
{
    int C,Dimension;
    float Sistema[101][102];
    PideDatos(&Dimension,Sistema);
    printf("\n\n\nEl SISTEMA introducido es el siguiente: \n\n");
    EscribeDatos(Dimension,Sistema);
    ResuelveGauss(Dimension,Sistema);
    printf("\n\n\nLas soluciones son:\n");
    for(C=1;C<=Dimension;C++) printf("\n X%d=%f\n",C,Sistema[C][Dimension+1]);
   
    scanf("");
    return(0);
}


void PideDatos(int *Dim,float Sist[][102])
{
    int A,B;
    printf("\n\n ||RESUELVE SISTEMAS LINEALES DETERMINADOS POR GAUSS||");
    printf("\n\n\n Introduce el numero de incognitas:(menor que 100)");
    scanf("%d",&*Dim);
    printf("\n\n PASE A INTRODUCIR CADA COMPONENTE DEL SISTEMA (A|B):");
    printf("\n\n MATRIZ A:\n");
    for(A=1;A<=*Dim;A++) for(B=1;B<=*Dim;B++){
        printf("\n Termino A(%d,%d):",A,B); scanf("%f",&Sist[A][B]);}
    printf("\n\n\n VECTOR B:\n");
    for(A=1;A<=*Dim;A++){
        printf("\n Termino B(%d):",A);scanf("%f",&Sist[A][*Dim+1]);
    }}

void EscribeDatos(int Dim, float Sist[][102])
{
    int A,B;
    for(A=1;A<=Dim;A++){
        for(B=1;B<=(Dim+1);B++){
            printf("%7.2f",Sist[A][B]);
            if(B==Dim) printf("   |");}
        printf("\n");
    }}

void ResuelveGauss(int Dim, float Sist[][102])
{
    int NoCero,Col,C1,C2,A;
    float Pivote,V1;
   
    for(Col=1;Col<=Dim;Col++){
        NoCero=0;A=Col;
        while(NoCero==0){
           if((Sist[A][Col]>0.0000001)||((Sist[A][Col]<-0.0000001))){
                NoCero=1;}
            else A++;}
        Pivote=Sist[A][Col];
        for(C1=1;C1<=(Dim+1);C1++){
            V1=Sist[A][C1];
            Sist[A][C1]=Sist[Col][C1];
            Sist[Col][C1]=V1/Pivote;}
        for(C2=Col+1;C2<=Dim;C2++){
            V1=Sist[C2][Col];
            for(C1=Col;C1<=(Dim+1);C1++){
                Sist[C2][C1]=Sist[C2][C1]-V1*Sist[Col][C1];}
    }}
   
    for(Col=Dim;Col>=1;Col--) for(C1=(Col-1);C1>=1;C1--){
        Sist[C1][Dim+1]=Sist[C1][Dim+1]-Sist[C1][Col]*Sist[Col][Dim+1];
        Sist[C1][Col]=0;
    }
}


 


Un saludo. 

miércoles, 15 de mayo de 2013

Succesión de Fibonacci en C

El programa calcula e imprime en pantalla los valores de los términos de la famosa sucesión de Fibonacci. Cada término de la sucesión de Fibonacci se define como la suma de los dos términos anteriores. Las dos primeras componentes de la sucesión son 1 y 1, a partir de los cuales se pueden sacar todos los demás términos.
Esta sucesión es muy utilizada para describir distintos fenómenos, como son el crecimiento de una población de conejos en medio salvaje y sin depredadores. También nos permite modelar otros fenómenos como son el crecimiento de muchas plantas o el de las galaxias.

Aquí pongo el Código de la sucesión de Fibonacci en C:



/*PROGRAMA PARA CALCULARA LA SERIE DE FRIBONACCI EN C/C++*/
#include <stdio.h>

int ind,c,ter1=1,ter2=0;
char imp,corr=0;

int main(void)
{
    int aux;

    printf("CALCULA LA SERIE DE FIBONACCI:");
    printf("Introduce el indice a calcular: ");
    fflush(stdin); scanf("%i",&ind);
    while (corr==0)
    {
        printf("Quieres imprimir toda la serie? (S=Si,N=No):  ");
        fflush(stdin);
        scanf("%c",&imp);
        if ((imp=='S')||(imp=='s'))
        {
            printf("\nLa serie hasta el termino %i es:\n",ind);
            for(c=1;c<=ind;c++)
            {
                printf("%6i",ter1);
                aux=ter2;
                ter2=ter1;
                ter1=ter1+aux;
            }
            corr=1;
        }
        else if ((imp=='N')||(imp=='n'))
        {
            for(c=1;c<=ind;c++)
            {
                aux=ter2;
                ter2=ter1;
                ter1=ter1+aux;
            }
            printf("El termino %i vale: %i",ind,ter2);
            corr=1;
        }
        else printf("Solo puede introducir N o S.\n\n");
}}


Se ha utilizado la función fflush para limpiar el buffer del teclado, ya que daba probelmas.

Un saludo.

domingo, 12 de mayo de 2013

Método Burbuja de Ordenación en C/C++

A continuación se presenta el código del método de ordenación denominado BURBUJA, que nos permite ordenar las componentes de un array de mayor a menor. El método consiste en ir comparando parejas de números consecutivos del array, y si el de segundo es mayor que el primero, el primero pasa a ser el segundo y viceversa. Este proceso se realiza a lo largo de todo el array tantas veces como sea necesario hasta que no se produzcan cambio (Por eso el uso de la bandera cambios). El resultado es el array ordenado de manera descendente.

Aquí les dejo una captura del programa:

Y aquí el código:




/*METODO BURBUJA DE ORDENACIÓN*/
#include <stdio.h>

int const Tam=100;
int N,C;

void ordena(float dats[], int dim);
void imprime(float dats[], int dim);

int main(void)
{
    float datos[Tam];
    printf("Numero que vas a introducir:");scanf("%i",&N);
    for(C=1;C<=N;C++)
    {
        printf("Numero %i: ",C);scanf("%f",&datos[C]);
    }
    ordena(datos,N);
    imprime(datos,N);
    return 0;
}

void ordena(float dats[],int dim)
{
    float aux;

    int cambio=1,cont;
    while (cambio==1)
    {
        cambio=0;
        for(cont=1;cont<dim;cont++)
            if(dats[cont]<dats[cont+1]){
                aux=dats[cont];
                dats[cont]=dats[cont+1];
                dats[cont+1]=aux;
                cambio=1;
    }}
}

void imprime(float dats[], int dim)
{
    printf("\n\nEl vector ordenado de mayor a menor es el siguiente:\n");
    int cont;
    for(cont=1;cont<=dim;cont++) printf("%f\n",dats[cont]);
}


Saludos.

martes, 30 de abril de 2013

Calculo Determinante de una Matriz en C/C++

Calcula el determinante de una matriz, previo escalonamiento (método de gauss-jordan), mediante la multiplicación de los términos de su diagonal.
El hecho de realizar permutaciones entre filas, o la suma y resta entre filas, no afecta al módulo del determinante de la matriz, pero si al signo (Fácilmente verificable).
El signo se ve afectado por cada permutación realizada para llegar a la matriz escalonada. Es decir, si el número de permutaciones realizadas es un número par, el producto de los términos de la diagonal será el determinante. Si por el contrario, las permutaciones realizadas son impares, el determinante será el producto de los términos de la diagonal pero cambiados de signo.
Este método es mucho más eficiente que el usado anteriormente en otros programas (Aquí en C y aquí en Pascal) que trabajaba con funciones recursivas y que estaban basados en el desarrollo de Laplace.




Aquí les dejo el código:


#include <stdio.h>

int const Tam=101;

void PideDatos(int *Dim, float Mat[][Tam]);
void EscribeDatos(int Dim, float Mat[][Tam]);
void CalcDet(int Dim, float Mat[][Tam]);


int main(void)
{
int C,Dimension;
float Matriz[Tam][Tam];
PideDatos(&Dimension,Matriz);
printf("\n\n\nCalcula DETERMINANTE: \n\n");
EscribeDatos(Dimension,Matriz);
CalcDet(Dimension,Matriz);

scanf("%d");
return(0);
}


void PideDatos(int *Dim,float Mat[][Tam])
{
int A,B;
printf("\n\n ||CALCULA DETERMINANTE ESCALONANDO MATRIZ||");
printf("\n\n\n Introduce la dimension de la matriz:");
scanf("%d",&*Dim);
printf("\n\n INTRODUCIR CADA COMPONENTE DE LA MATRIZ:");
for(A=1;A<=*Dim;A++) for(B=1;B<=*Dim;B++){
printf("\n Termino A(%d,%d):",A,B); scanf("%f",&Mat[A][B]);}
}

void EscribeDatos(int Dim, float Mat[][Tam])
{
int A,B;
for(A=1;A<=Dim;A++){
for(B=1;B<=(Dim);B++)
printf("%7.2f",Mat[A][B]);
printf("\n");
}}

void CalcDet(int Dim, float Mat[][Tam])
{
 int NoCero,Col,C1,C2,A,NoReg,Perm=0/*permutaciones*/;
 float Pivote,V1,Det=1;

 for(Col=1;Col<=Dim;Col++){
  NoCero=0;A=Col;
  while((NoCero==0)&&(A<=Dim)){
   if((Mat[A][Col]>0.0000001)||((Mat[A][Col]<-0.0000001))){
    NoCero=1;}
   else A++;}
  if (A>Dim) NoReg=1;
  if (A!=Col) Perm++;
  Pivote=Mat[A][Col];
  for(C1=1;C1<=(Dim);C1++){
   V1=Mat[A][C1];
   Mat[A][C1]=Mat[Col][C1];
   Mat[Col][C1]=V1;}
  for(C2=Col+1;C2<=Dim;C2++){
   V1=Mat[C2][Col];
   for(C1=Col;C1<=(Dim);C1++){
    Mat[C2][C1]=Mat[C2][C1]-((V1/Pivote)*Mat[Col][C1]);}}
 }
    for(C2=1;C2<=Dim;C2++) Det=Det*Mat[C2][C2];
 A=Perm;
 if ((A%2)==1) Det=-Det; /*Caso de permutaciones impares*/
 if (NoReg==1) Det=0;
    printf("El determinante de la matriz es:   %f", Det);

}



Y aquí el código para poner a prueba el programa. Se introduce el tamaño de la matriz, el programa genera todas las componentes de la matriz de manera aleatoria (Únicamente introduce 1s y 0s), y se calcula su determinante:

(Se ha dejado comentada la función para imprimir la matriz)

#include <stdio.h>
#include <stdlib.h> /*Para los números aleatorios*/

int const Tam=200;

void PideDatos(int *Dim, float Mat[][Tam]);
void EscribeDatos(int Dim, float Mat[][Tam]);
void CalcDet(int Dim, float Mat[][Tam]);


int main(void)
{
 int C,Dimension;
 float Matriz[Tam][Tam];
 PideDatos(&Dimension,Matriz);
 printf("\n\n\nCalcula DETERMINANTE: \n\n");
 EscribeDatos(Dimension,Matriz);
 CalcDet(Dimension,Matriz);

 scanf("%d");
 return(0);
}


void PideDatos(int *Dim,float Mat[][Tam])
{
 int A,B;
 printf("\n\n ||CALCULA DETERMINANTE ESCALONANDO MATRIZ||");
 printf("\n\n\n Introduce la dimension de la matriz:");
 scanf("%d",&*Dim);
 for(A=1;A<=*Dim;A++) for(B=1;B<=*Dim;B++)
  Mat[A][B]=rand()%2;
}

void EscribeDatos(int Dim, float Mat[][Tam])
{
 int A,B;
 for(A=1;A<=Dim;A++){
  for(B=1;B<=(Dim);B++)
   printf("%7.2f",Mat[A][B]);
  printf("\n");
 }}

void CalcDet(int Dim, float Mat[][Tam])
{
 int NoCero,Col,C1,C2,A,NoReg,Perm=0/*permutaciones*/;
 float Pivote,V1,Det=1;

 for(Col=1;Col<=Dim;Col++){
  NoCero=0;A=Col;
  while((NoCero==0)&&(A<=Dim)){
   if((Mat[A][Col]>0.0000001)||((Mat[A][Col]<-0.0000001))){
    NoCero=1;}
   else A++;}
  if (A>Dim) NoReg=1;
  if (A!=Col) Perm++;
  Pivote=Mat[A][Col];
  for(C1=1;C1<=(Dim);C1++){
   V1=Mat[A][C1];
   Mat[A][C1]=Mat[Col][C1];
   Mat[Col][C1]=V1;}
  for(C2=Col+1;C2<=Dim;C2++){
   V1=Mat[C2][Col];
   for(C1=Col;C1<=(Dim);C1++){
    Mat[C2][C1]=Mat[C2][C1]-((V1/Pivote)*Mat[Col][C1]);}}
 }
    for(C2=1;C2<=Dim;C2++) Det=Det*Mat[C2][C2];
 A=Perm;
 if ((A%2)==1) Det=-Det; /*Caso de permutaciones impares*/
 if (NoReg==1) Det=0;
    printf("El determinante de la matriz es:   %f", Det);

}



Un saludo.

lunes, 29 de abril de 2013

Chonificador en C/C++

Este programa convierte un texto escrito correctamente, a otro texto semejante, pero esta vez escrito por un Choni (Llámese Choni, Pituti, Nini, Macarra, Bacala...).
Se introduce el nombre del fichero de texto a convertir y ya está. Este programa sirve para ver el uso de los ficheros de texto, y trabajar con caracteres ASCII.

Y por si algún Choni le da por hacer algo útil:



ESteee PrOgrAmaaa KoNvIerTEEE un texTOOO ESKritOOO KoRreKtaMEnTE, AAA OTRooo TExTOOO shEMEJanTE, pErooo EstAAA VeZ eSKriTooo PoR Un XonIII (LLámeshEEE Xoni, PITuti, NINI, MaKaRrA, BAKaLA...).
ShEEE INTrODUKeee eL NOmbrEEE dEL fIXeRooo deee texTOOO AAA KoNVertIr Y yAAA eSTá. EstEEE pROGRAMAAA shirVEEE Paraaa ver eL UShOOO DEEE LOS fIXErOS dEEE TExTO, Y TRaBaJaR Kon KarAKterEs ASKII.

(¡¡Oh Dios!! ¡Cuántas cosas subrayadas en rojo!)


Las chonificaciones realizadas son:
    1º) Alternancia de mayúsculas y minúsculas.
    2º) Cambio de C por K.
    3º) Cambio de QU por Q.
    4º) Cambio de CH por X.
    5º) Multiplicar el numero de vocales al final de una palabra.
    6º) Introduce H entre S y vocal. (Doy fe de que lo he visto por ahí).
    7º) Coloca H al final de las palabras acabadas en vocal.


Ejemplo de ejecución:

Nombre del fichero:


Entrada y Salida:





CODIGO:




/*Programa para convertir de lenguaje de humano, a lenguaje Choni*/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(void)
{
FILE *dat,*dat2;
int const ascii='a'-'A';

char nombre[50],C1,Voc,antVoc,mayus,antS,antQ,imp,leida;
int a;

printf("Nombre del fichero a leer (Con la extension .txt): "); 
    scanf("%s", &nombre);


if (fopen(nombre,"r")==NULL) 
printf("\nEl fichero no existe.\n\n");
else
    {
dat=fopen(nombre,"r");
dat2=fopen("SalidaChoni.txt","w");
fscanf(dat,"%c",&C1);
antS=antVoc=antQ=imp=leida=0;
while (!feof(dat))
{
            /*Sortea si se pasa de minus a myus*/
            mayus=(rand()%7)+1;
            imp=0;

            /*Chonifica minúsculas a mayúsculas*/  
if (((C1<='z')&&(C1>='a'))&&(mayus<5)) C1=C1-ascii;
            
            
             
            /*Imprime en fichero de salida*/
            /*Mete H entre S y vocal*/
            if ((antS==1)&&((C1=='A')||(C1=='E')||(C1=='I')||(C1=='O')||(C1=='U')
            ||(C1=='a')||(C1=='e')||(C1=='i')||(C1=='o')||(C1=='u')))
            {
               fprintf(dat2,"%c",'h');
               fprintf(dat2,"%c",C1); 
               imp=1;
            }
            
            /*Si la última letra de la palabra es una vocal, la multiplica por 3*/
            if ((antVoc==1)&&(C1==' '))
            {
               fprintf(dat2,"%c",Voc);fprintf(dat2,"%c",'h');
               fprintf(dat2,"%c",C1);
               imp=1; 
            }
            
            /*Quita la u a la partícula qu*/
            if (antQ==1) imp=1; 
            
            /*Pasa de ch a x*/
            if ((C1=='C')||(C1=='c')) 
            {
                fscanf(dat,"%c",&C1);                       
                if ((C1=='H')||(C1=='h')) fprintf(dat2,"%c",'X');
                else 
                {
                    leida=1;
                    if ((C1=='A')||(C1=='O')||(C1=='U')||(C1=='a')||(C1=='o')||
                    (C1=='u')) fprintf(dat2,"%c",'K');
                    else fprintf(dat2,"%c",'C');
                    if (!feof(dat)) fprintf(dat2,"%c",C1);
                }
                imp=1;
            }
            
            /*Imprime en el caso de que se tenga que imprimir*/
            if (imp==0) fprintf(dat2,"%c",C1);
            
            antS=antVoc=antQ=imp=leida=0;
            
            /*Actualiza valor de anteriores*/
            if ((C1=='A')||(C1=='E')||(C1=='I')||(C1=='O')||(C1=='U')
            ||(C1=='a')||(C1=='e')||(C1=='i')||(C1=='o')||(C1=='u'))
            {
                antVoc=1;
                Voc=C1;
            }
            
            if ((C1=='q')||(C1=='Q')) antQ=1;
            
            if ((C1=='S')||(C1=='s')) antS=1;
            
            if (leida==0) fscanf(dat,"%c",&C1);
}
fclose(dat);
        fclose(dat2);
}
return 0;
}


Aquí también un enlace con el Chonificador para que se pueda probar:
Chonificador.

Acepto sugerencias para seguir chonificando.



domingo, 28 de abril de 2013

Calculo matriz INVERSA en C/C++

El siguiente programa es semejante al desarrollado anteriormente en Pascal. Comparte gran parte de la estructura con el programa que resuelve sistemas mediante Gauss (Entrada) Se calcula la matriz inversa, realizando las mismas operaciones que se realizan para diagonalizar la matriz, sobre la matriz unidad. Finalmente, después de todas las transformaciones sobre la matriz identidad, obtenemos la matriz inversa. Este método es el más simple a la hora de obtener la matriz inversa.
Hay que recordar que para que una matriz se pueda invertir, tiene que ser no singular, es decir, con determinante distinto de cero.

Puedes comprobar si la matriz tiene determinante nulo con el código del enlace siguiente.
DETERMINANTE

CODIGO:


#include <stdio.h>

int const Tam=100;
void PideDatos(int *Dim, float Sist[][Tam]);
void EscribeDatos(int Dim, float Sist[][Tam]);
void Invierte(int Dim, float Sist[][Tam], float Inv[][Tam]);


int main(void)
{
int C,Dimension;
float Sistema[Tam][Tam],Inversa[Tam][Tam];
PideDatos(&Dimension,Sistema);
printf("\n\n\nLa matriz introducida es la siguiente: \n\n");
EscribeDatos(Dimension,Sistema);
Invierte(Dimension,Sistema,Inversa);
printf("\n\n\nLa inversa de la matriz es: \n\n");
EscribeDatos(Dimension,Inversa);

scanf("%d");
return(0);
}


void PideDatos(int *Dim,float Sist[][Tam])
{
int A,B;
    printf("\n\n ||CALCULA INVERSA||");
printf("\n\n\n Introduce el tamano de la matriz:");
scanf("%d",&*Dim);
printf("\n\n Introducir cada componente de la matriz A:");
for(A=1;A<=*Dim;A++) for(B=1;B<=*Dim;B++){
printf("\n Termino A(%d,%d):",A,B); scanf("%f",&Sist[A][B]);}
}

void EscribeDatos(int Dim, float Sist[][Tam])
{
int A,B;
for(A=1;A<=Dim;A++){
for(B=1;B<=(Dim);B++) printf("%7.2f",Sist[A][B]);
printf("\n");
}}

void Invierte(int Dim, float Sist[][Tam], float Inv[][Tam])
{
int NoCero,Col,C1,C2,A;
float Pivote,V1,V2;

/*Se inicializa la matriz inversa, como la matriz identidad:*/
for(C1=1;C1<=Dim;C1++) for(C2=1;C2<=Dim;C2++)
   if (C1==C2) Inv[C1][C2]=1; else Inv[C1][C2]=0;

for(Col=1;Col<=Dim;Col++){
NoCero=0;A=Col;
while(NoCero==0){
if((Sist[A][Col]>0.0000001)||((Sist[A][Col]<-0.0000001))){
NoCero=1;}
else A++;}
Pivote=Sist[A][Col];
for(C1=1;C1<=Dim;C1++){
V1=Sist[A][C1];
Sist[A][C1]=Sist[Col][C1];
Sist[Col][C1]=V1/Pivote;
V2=Inv[A][C1];
Inv[A][C1]=Inv[Col][C1];
Inv[Col][C1]=V2/Pivote;
            }
for(C2=Col+1;C2<=Dim;C2++){
V1=Sist[C2][Col];
for(C1=1;C1<=Dim;C1++){
Sist[C2][C1]=Sist[C2][C1]-V1*Sist[Col][C1];
                Inv[C2][C1]=Inv[C2][C1]-V1*Inv[Col][C1];}
}}

/*Aqui ya esta triangularizada, con 1s en diagonal, ahora se diagonaliza*/
for(Col=Dim;Col>=1;Col--) for(C1=(Col-1);C1>=1;C1--)
    {
        V1=Sist[C1][Col]; 
        for(C2=1;C2<=Dim;C2++){
   Sist[C1][C2]=Sist[C1][C2]-V1*Sist[Col][C2];
   Inv[C1][C2]=Inv[C1][C2]-V1*Inv[Col][C2];
   }}
}




Un Saludo.

sábado, 20 de abril de 2013

Lectura palabras entrecomilladas en C/C+

Se guardan en fichero de texto todas las palabras entrecomilladas de un fichero de texto de entrada:



#include <stdio.h>
#include <string.h>

int main(void)
{
FILE *dat,*dat2;
char nombre[50],c;

printf("Nombre del fichero a leer: "); scanf("%s", &nombre);


if (fopen(nombre,"r")==NULL) 
printf("\nEl fichero no existe.\n\n");
else
    {
dat=fopen(nombre,"r");
dat2=fopen("salida.txt","w");
fscanf(dat,"%c",&c);
while (!feof(dat))
{
if (c=='"')
{
                fscanf(dat,"%c",&c);       
                while ((!feof(dat))&&(c!='"'))
                {
                      /*Aquí es donde se guardan los datos entre comillas*/
                      /*En este caso imprime en fichero de texto*/
                      fprintf(dat2,"%c",c);
                      fscanf(dat,"%c",&c); 
                }
                fprintf(dat2,"\n");            
            }
fscanf(dat,"%c",&c);
}
fclose(dat);
}
printf("salio");
getchar();
return 0;
}


Un saludo.

jueves, 18 de abril de 2013

Cifrado CESAR en C/C++

Les presento el código del encriptador CESAR. Introducido un fichero de texto, genera un fichero con el mismo contenido, pero cifrado mediante este método. La información a cerca del cifrado se presenta en el encabezado del programa.
Quiero recordar que en el blog hay disponible un tema sobre el mismo tipo de cifrado, pero en Pascal, en vez de en C. Además también hay otro tipo de codificación y decodificación que usa un método algo más complejo.
Debido a la simplicidad de este método, el cifrado CESAR está actualmente en casi total desuso.

Un poco de historia: El nombre de CESAR proviene de que según la historia, el primer personaje en usarlo fue Julio Cesar, con un desplazamiento de 3 letras, para comunicarse con los mandos del ejercito romano y no ser descubierto por personas ajenas a él.

CÓDIGO:




/*CIFRADO CESAR EN C/C++*/

/*Este programa se va a usar para llevar a cabo una codificación de un fichero
de texto, mediante el codificado CESAR, que es uno de los métodos más simples
de encriptar.
La variable trans==translación de encriptación, es la que indica cuantas letras
se va a correr el abecedario hacia la derecha. Ejemplo: 
      trans=3 
      c1=Caracter decodificado
      c2=Caracter codificado
      c2=c1+trans
      Entonces en nuestro caso si c1='A'
      c2='A'+3='D'

El programa solo codifica letras, tanto mayúsculas como minúsculas:
del ASCII 65 ('A') al 90 ('Z') y del 97 ('a') al 122 ('z').
*/

#include <stdio.h>
#include <string.h>

int main(void)
{
FILE *dat1,*dat2;
char nombre1[50],nombre2[50],c;
int trans;

printf("Seleccione translacion de encriptacion: "); scanf("%d", &trans);
printf("Nombre del fichero a codificar: "); scanf("%s", &nombre1);
printf("Nombre del fichero donde guardar codificado: "); scanf("%s", &nombre2);


if (fopen(nombre1,"r")==NULL) 
printf("\nEl fichero no existe.\n\n");
else
    {
dat1=fopen(nombre1,"r");/*Se abre en modo lectura*/
dat2=fopen(nombre2,"w");/*Se abre en modo escritura*/
fscanf(dat1,"%c",&c);
while (!feof(dat1))
{
/*Se codifica el caracter*/
if ((c>='A')&&(c<='Z'))
{
                c=((c+trans-'A')%('Z'-'A'+1))+'A';            
            }
            else if ((c>='a')&&(c<='z'))
            {
                c=(c+trans-'a')%('z'-'a'+1)+'a';
            }
            
/*Se escribe el caracter en el codificado*/
fprintf(dat2,"%c",c);

/*Se lee un nuevo caracter*/
fscanf(dat1,"%c",&c);
}
fclose(dat1);
fclose(dat2);/*Se cierran ambos ficheros*/
}
}




Y aquí un ejemplo de ejecución:





Un saludo.

domingo, 7 de abril de 2013

Determinante matriz en C/C++

Cálculo del determinante en C/C++ mediante el uso de una función recursiva que se basa en el desarrollo de Laplace. Esta regla permite reducir el cálculo del determinante, al cálculo de sumas y productos. Este método no es ni mucho menos el más eficiente, debido a la función recursiva. Existen otros métodos, basados en la ortogonalización de matrices (Método de Gram-Smith (En Pascal)) que permiten el cálculo numérico de una manera mucho más eficiente para el ordenador.

Este programa ya fue implementado en Pascal, y ahora se ha implementado en C/C++. La limitación de este programa usando una función recursiva es evidente, y únicamente puede llegar a procesar matrices de 20x20.



/*CÁLCULA EL DETERMINANTE DE UNA MATRIZ EN C/C++*/

#include <stdio.h>

int const max=11;
int vis;
float M[max+1][max+1]; /*EN LA POSICION 0,0 SE GUARDA LA DIMENSION DE M*/
float Det;

float Determinante(float Mat[][max+1]);

int main(void)
{
    printf("\n\n  CALCULO DEL DETERMINANTE DE UNA MATRIZ POR RECURSIVIDAD");
    printf("\n\n                CYPASCAL.BLOGSPOT.COM\n\n\n\n");
    int cont1, cont2;
    printf("Introduce el tamano de la matriz: "); scanf("%f", &M[0][0]);
    for (cont1=1;cont1<=M[0][0];cont1++)
    for (cont2=1;cont2<=M[0][0];cont2++){
        printf("(%2i,%2i)  ", cont1,cont2); 
        scanf("%f",&M[cont1][cont2]);
    }
    printf("Tamano: %f \n La matriz introducida es: \n",M[0][0]);
    for (cont1=1;cont1<=M[0][0];cont1++){
        for (cont2=1;cont2<=M[0][0];cont2++)
            printf(" %5f", M[cont1][cont2]);
        printf("\n");
    }
    printf("Visualizar matrices intermedias? (1=SI, 0=NO): ");scanf("%i",&vis);
    Det=Determinante(M);
    printf("El determiante de M vale: %f",Det);
    scanf("%f",&Det);
    return 0;
}

float Determinante(float Mat[][max+1])
{
      float aux1,aux2,Maux[max+1][max+1];
      int cont1, cont2, cont3, cont4, cont5;
      if (Mat[0][0]==1)
         return (Mat[1][1]);
      else
      {
          aux1=0;
          aux2=1;
          for (cont1=1; cont1<=Mat[0][0];cont1++)
          {
              Maux[0][0]=Mat[0][0]-1;
      
              for (cont2=1;cont2<=Mat[0][0];cont2++)
              for (cont3=1;cont3<=Maux[0][0];cont3++){
                  if (cont2<cont1) 
                     Maux[cont2][cont3]=Mat[cont2][cont3+1];
                  else if (cont2>cont1) 
                     Maux[cont2-1][cont3]=Mat[cont2][cont3+1];
              }
              /*ESTOS DOS "FOR" SON PARA GENERAR MATRIZ ADJUNTA*/
              if (vis==1){
                      printf("\n\n");
                      for (cont4=1;cont4<=Maux[0][0];cont4++){
                          for (cont5=1;cont5<=Maux[0][0];cont5++)
                              printf(" %5f", Maux[cont4][cont5]);
                          printf("\n");
              }}/*SE IMPRIMEN EN PANTALLA LAS MATRICES INTERMEDIAS*/    
              aux1=aux1+Mat[cont1][1]*aux2*Determinante(Maux);
              aux2=aux2*(-1);/*ALTERNA 1 Y -1*/
          }
          return (aux1);
}}


Un saludo.