five.c

Acoplamiento para IE ESIME Zac

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

/*********************************************************
	      	     DEFINICIONES
*********************************************************/
//Estructura de numero imaginario
typedef struct imaginario
{
	double re;	//Parte Real
	double im;	//Parte imaginaria	
}Imaginario;

//Estructura de matriz
typedef struct matriz
{
	int m;			//Numero de filas
	int n;			//Numero de columnas	
	Imaginario ** a;	//Arreglo de imaginarios para la matriz
}Matriz;

/*********************************************************
	      	     PROTOTIPOS
*********************************************************/
Matriz InitMatriz(int, int);
void FreeMatriz(Matriz);
void MatrizInversa(Matriz *);

//Funcion
void ejercicio(int, char);

//Operaciones de imaginarios
Imaginario SumaIm(Imaginario, Imaginario);
Imaginario RestaIm(Imaginario, Imaginario);
Imaginario MultiplicacionIm(Imaginario, Imaginario);
Imaginario DivisionIm(Imaginario, Imaginario);
Imaginario Conjugado(Imaginario);

void imprimeMatriz(Matriz);

int main()
{
	char opcion;
	int Nodos;

	printf("\n---------ACOPLAMIENTO------------\n");

	//Vemos si hay acoplamiento
	printf("¿Existe Acoplamiento?(s/n) ");
	opcion = getchar();

	printf("No. de nodos del sistema: ");
	scanf("%i",&Nodos);

	ejercicio(Nodos, opcion);
}

void ejercicio(int Nodos, char acoplamiento)
{
	printf("\n---------ENTRADA------------\n");
	printf("Nodos del sistema: %i\n", Nodos);
	printf("Sistema acoplado: %c\n\n", acoplamiento);

	//Inicializamos la matriz Z, Z' y Y de dim Nodos x Nodos
	Matriz Z = InitMatriz(Nodos, Nodos);
	Matriz Zp = InitMatriz(Nodos, Nodos);
	Matriz Y = InitMatriz(Nodos, Nodos);

	//Imaginario aux, 1 + 0i = 1;
	Imaginario aux;
	aux.re = 1;
	aux.im = 0;

	int i, j;

	//Pedimos los datos de Z
	printf("Valores de Z\n");

	for(i = 0; i < Z.m; i++)
	{
		for(j = i + 1; j < Z.n; j++)
		{
			printf("Z(%i,%i) = Z(%i,%i):\n", (i + 1), (j + 1), (j + 1), (i + 1));
			printf("\tReal: ");
			scanf("%lf",&Z.a[i][j].re);
			printf("\tImaginaria: ");
			scanf("%lf",&Z.a[i][j].im);

			Z.a[j][i].re = Z.a[i][j].re;
			Z.a[j][i].im = Z.a[i][j].im;
		}
	}

	//Pedimos los datos de Z'
	printf("\nValores de Z'\n");

	for(i = 0; i < Zp.m; i++)
	{
		for(j = i + 1; j < Zp.n; j++)
		{
			printf("Z'(%i,%i) = Z'(%i,%i):\n", (i + 1), (j + 1), (j + 1), (i + 1));
			printf("\tImaginaria: ");
			scanf("%lf",&Zp.a[i][j].im);

			Zp.a[j][i].re = Zp.a[i][j].re = 0;	//La parte real vale cero
			Zp.a[j][i].im = Zp.a[i][j].im;
		}
	}

	//Calculamos las diagonales
	for(i = 0; i < Z.m; i++)
	{
		Z.a[i][i].re = Z.a[i][i].im = 0;

		for(j = 0; j < Z.n; j++)
			if(i != j)
			{
				//Sumamos Z[i][j] + Z'[i][j]
				Z.a[i][i].re += Z.a[i][j].re;
				Z.a[i][i].im += Z.a[i][j].im + Zp.a[i][j].im / 2;

				//Una vez que se sumo lo mult x-1
				//Z.a[i][j].re = (-1) * Z.a[i][j].re;
				//Z.a[i][j].im = (-1) * Z.a[i][j].im;
			} 
	}

	//Si se indicio que hay acoplamiento
	if(acoplamiento == 'S' || acoplamiento == 's')
	{
		//Nodos
		int Nodo_Ref, Nodo_1, Nodo_2;
		Imaginario Zm;

		printf("\nValores de acoplamiento\n");
		printf("Nodo de referencia: ");
		scanf("%i",&Nodo_Ref);

		printf("Nodo 1: ");
		scanf("%i",&Nodo_1);

		printf("Nodo 2: ");
		scanf("%i",&Nodo_2);

		printf("Zm: \n");
		printf("\tReal: ");
		scanf("%lf",&Zm.re);	
		printf("\tImaginario: ");
		scanf("%lf",&Zm.im);	

		//Calculamos Ym = 1/Zm = aux/ZM
		Imaginario Ym = DivisionIm(aux, Zm);
 
		//Afecatmos los valores donde Ym afecta
		//Para I[Nodo_Ref]
			Z.a[Nodo_Ref - 1][Nodo_Ref - 1] = SumaIm(Z.a[Nodo_Ref - 1][Nodo_Ref - 1], Ym);
			Z.a[Nodo_Ref - 1][Nodo_2 - 1] = SumaIm(Z.a[Nodo_Ref - 1][Nodo_2 - 1], Ym);

			Z.a[Nodo_Ref - 1][Nodo_Ref - 1] = SumaIm(Z.a[Nodo_Ref - 1][Nodo_Ref - 1], Ym);
			Z.a[Nodo_Ref - 1][Nodo_1 - 1] = SumaIm(Z.a[Nodo_Ref - 1][Nodo_1 - 1], Ym);

		//Para I[Nodo_1]
			Z.a[Nodo_1 - 1][Nodo_Ref - 1] = SumaIm(Z.a[Nodo_1 - 1][Nodo_Ref - 1], Ym);
			Z.a[Nodo_1 - 1][Nodo_2 - 1] = SumaIm(Z.a[Nodo_1 - 1][Nodo_2 - 1], Ym);

		//Para I[Nodo_2]
			Z.a[Nodo_2 - 1][Nodo_Ref - 1] = SumaIm(Z.a[Nodo_2 - 1][Nodo_Ref - 1], Ym);
			Z.a[Nodo_2 - 1][Nodo_1 - 1] = SumaIm(Z.a[Nodo_2 - 1][Nodo_1 - 1], Ym);
	}

	//Multiplicamos x-1 los elementos fuera de la diagonal
	for(i = 0; i < Z.m; i++)
		for(j = 0; j < Z.n; j++)
			if(i != j)
			{
				Z.a[i][j].re = (-1) * Z.a[i][j].re;
				Z.a[i][j].im = (-1) * Z.a[i][j].im;
			}

	//Imprimimos la matriz capturada
	printf("\nZbarra = \n");
	imprimeMatriz(Z);

	//Formamos la matriz Y = 1/Z
	for(i = 0; i < Z.m; i++)
		for(j = 0; j < Z.n; j++)
			Y.a[i][j] = DivisionIm(aux, Z.a[i][j]);

	//Obtenemos la matriz inversa de Y
	MatrizInversa(&Y);

	printf("\nYbus = \n");
	imprimeMatriz(Y);

	//Liberamos los recursos usados
	FreeMatriz(Z);
	FreeMatriz(Zp);
	FreeMatriz(Y);
}


/************************************************************************
Nombre: InitMatriz
Parameteros: 
	m.- Numero de filas
	n.- NUmero de columnas
Descripción: Reservar los recursos para una matriz
Retorno: La matriz formada
*************************************************************************/
Matriz InitMatriz(int m, int n)
{
	register int i;

	Matriz matriz;
	matriz.m = m;
	matriz.n = n;

	//Reservamos espacio para las filas
	matriz.a = (Imaginario **)malloc(sizeof(Imaginario *) * matriz.m);

	//Recorremos las filas
	for(i = 0; i < matriz.m; i++)	
		//Reservamos espacio para la fila i
		matriz.a[i] = (Imaginario *)malloc(sizeof(Imaginario) * matriz.n);

	return matriz;
}

/************************************************************************
Nombre: MatrizInvers
Parameteros: 
	m.- Matriz a la cual se le obtendrá su inversa
Descripción: Calcular la inversa de una matriz
Retorno: La inversa de la matriz
*************************************************************************/
void MatrizInversa(Matriz * m)
{
	register int i, j, k;
	Imaginario factor;

	//Cremaos la matriz identidad
	Matriz inv = InitMatriz(m -> m, m -> n);

	//Formamos la matriz identidad
	//Recorremos las filas
	for(i = 0; i < inv.m; i++)	
	{
		//Recorremos las columnas para inicializar los valores
		for(j = 0; j < inv.n; j++)
		{
			if(i == j)
			{
				inv.a[i][j].re = 1;
				inv.a[i][j].im = 0;
			}
			else
				inv.a[i][j].re = inv.a[i][j].im = 0;
		}
	}

	for(i = 0; i < m -> m; i++)
	{
		//Dividimos el renglon i entre a[i][i] para hacerlo 1
		factor = m -> a[i][i];

		for(j = 0; j < m -> n; j++)
		{
			//Dividimos la matriz original
			m -> a[i][j] = DivisionIm(m -> a[i][j], factor);
			//Dividimos la matriz identidad
			inv.a[i][j] = DivisionIm(inv.a[i][j], factor);
		}

		for(j = 0; j < m -> m; j++)
		{
			//Si no es el renglon actual en el que estamos
			if(j != i)
			{
				//Obtenemos el factor por el cual se debe multiplicar para hacer 0 a[j][i]
				factor = m -> a[j][i];

				for(k = 0; k < m -> n; k++)
				{
					//Sumamos a[j][k] por todo el renglon
					m -> a[j][k] = RestaIm(m -> a[j][k], MultiplicacionIm(factor, m -> a[i][k]));
					inv.a[j][k] = RestaIm(inv.a[j][k], MultiplicacionIm(factor, inv.a[i][k]));
				}
			}
		}
	}

	//Regresamos la matriz original pero con su inversa
	for(i = 0; i < inv.m; i++)
		for(j = 0; j < inv. n; j++)
			m -> a[i][j] = inv.a[i][j];

	//LIberamos los recursos
	FreeMatriz(inv);
}

/************************************************************************
Nombre: FreeMatriz
Parameteros: 
	m.- Matriz para liberar los recursos
Descripción: Liberar los recursos de una matriz
Retorno: Ninguno
*************************************************************************/
void FreeMatriz(Matriz m)
{
	register int i;

	//Liberamos los recursos de las filas
	for(i = 0; i < m.m; i++)	
		free(m.a[i]);

	free(m.a);
}

/************************************************************************
Nombre: SumaIm
Parameteros: 
	i1.- Numero imaginario 1
	i2.- Numero imaginario 2
Descripción: Sumar el numero i2 a i1
Retorno: Resultado de la suma
*************************************************************************/
Imaginario SumaIm(Imaginario i1, Imaginario i2)
{
	Imaginario res;

	//Realizamos la suma
	res.re = i1.re + i2.re;
	res.im = i1.im + i2.im;

	return res;
}

/************************************************************************
Nombre: SumaIm
Parameteros: 
	i1.- Numero imaginario 1
	i2.- Numero imaginario 2
Descripción: Restar el numero i2 a i1
Retorno: Resultado de la resta
*************************************************************************/
Imaginario RestaIm(Imaginario i1, Imaginario i2)
{
	Imaginario res;

	//Realizamos la resta
	res.re = i1.re - i2.re;
	res.im = i1.im - i2.im;

	return res;
}

/************************************************************************
Nombre: MultiplicacionIm
Parameteros: 
	i1.- Numero imaginario 1
	i2.- Numero imaginario 2
Descripción: Multiplicar el numero i1 por i2
Retorno: Resultado de la multiplicacion
*************************************************************************/
Imaginario MultiplicacionIm(Imaginario i1, Imaginario i2)
{
	Imaginario res;

	//Realizamos la multiplicacion
	res.re = i1.re * i2.re - i1.im * i2.im;
	res.im = i1.re * i2.im + i2.re * i1.im;

	return res;
}

/************************************************************************
Nombre: DivisionIm
Parameteros: 
	numerador.- Numero imaginario 1
	denominador.- Numero imaginario 2
Descripción: Multiplicar el numerador entre el denominador
Retorno: Resultado de la mdivision
*************************************************************************/
Imaginario DivisionIm(Imaginario numerador, Imaginario denominador)
{
	Imaginario res;

	//Realizamos la multiplicacion del numerador por el complejo conjugado del denominador
	res = MultiplicacionIm(numerador, Conjugado(denominador));

	//Obtenemos el residuo
	Imaginario aux = MultiplicacionIm(denominador, Conjugado(denominador));

	//Dividimos la parte real e imaginaria 
	res.re = res.re / aux.re;
	res.im = res.im / aux.re;

	return res;
}

/************************************************************************
Nombre: Conjugado
Parameteros: 
	i.- Numero imaginario
Descripción: Obtener el complejo conjudado de un numero imaginario
Retorno: El complejo conjugado
*************************************************************************/
Imaginario Conjugado(Imaginario i)
{
	Imaginario res;

	res.re = i.re;
	res.im = (-1) * i.im;

	return res;
}

/************************************************************************
Nombre: imprimeMatriz
Parameteros: 
	m.- Matriz a imprimir en pantalla
Descripción: Imprimir una matriz en pantalla
Retorno: Ninguno
*************************************************************************/
void imprimeMatriz(Matriz m)
{
	register int i, j;

	for(i = 0; i < m.m; i++)
	{
		for(j = 0; j < m.n; j++)
		{
			if(m.a[i][j].im >= 0)
				printf("%.2lf+%.2lfi\t", m.a[i][j].re, m.a[i][j].im);
			else
				printf("%.2lf%.2lfi\t", m.a[i][j].re, m.a[i][j].im);
		}
		printf("\n");
	}
}