#include <stdio.

h>
#include <stdlib.h>
#include <math.h>
#define MAX 50
#define DIM 3
#define PI 3.14
#define E 8.85e-12

void leer_posiciones(float X[][DIM], char nombre[], int *f, int

*c);

void leer_cargas(float m[][DIM+1], char nombre[], int *f, int *c);

void imprimir_posiciones(float m[][DIM], int *f, int *c);

void imprimir_cargas(float m[][DIM+1], int *f, int *c);

void campo_electrico(float ce[][DIM], float m[][DIM], float

n[][DIM+1], int *f, int *c, int *f1, int *c1);

void resta(float m[], float n[], float resta[]);

void modulo(float v[], float *mod);

void potencia(float *mod, int pot);

void inicializar_campoelectrico(int ce[][MAX], int *f, int *c);

int main()
{
int f, c, f1, c1;
float p[MAX][DIM], rel[MAX][DIM+1], ce[MAX][DIM];
char posiciones[50], qr[50];
printf("Ingrese el nombre del archivo: ");
scanf("%s%*c", &posiciones);
leer_posiciones(p, posiciones, &f, &c);
printf("\n");
imprimir_posiciones(p, &f, &c);
printf("\n");
printf("Ingrese el nombre del archivo: ");
scanf("%s%*c", &qr);
leer_cargas(rel, qr, &f1, &c1);
printf("\n");
imprimir_cargas(rel, &f1, &c1);
printf("\n");
inicializar_campoelectrico(ce, &f, &c);
campo_electrico(ce, p, rel, &f, &c, &f1, &c1);
printf("El campo electrico generado por las cargas marcadas en
el archivo es: \n");
printf("\n");
imprimir_posiciones(ce, &f, &c);
return 0;
}

void leer_posiciones(float m[][DIM], char nombre[], int *f, int

*c)
{
// en esta funcion se lee el archivo de las pocisiones a evaluar
desede el computador
int i,j;
FILE *fptr;
fptr = fopen(nombre,"r");
if (fptr == NULL)// al no encontrar el arhivo no puede
continuar
{
printf("Error! opening file");
return 0;
}
fscanf(fptr,"%d\n", f);
fscanf(fptr,"%d\n", c);
for (i=0; i<*f; i++)
{
for (j=0; j<*c; j++)
{
fscanf(fptr,"%f", &m[i][j]);
}
}
fclose(fptr);
}

void leer_cargas(float m[][DIM+1], char nombre[], int *f, int *c)

{
// el archivo de cargas al tener una columna mas es necesaria otra
funcion de la misma clase con diferentes componentes
int i,j;
FILE *fptr;
fptr = fopen(nombre,"r");
if (fptr == NULL)
{
printf("Error! opening file");
return 0;
}
fscanf(fptr,"%d\n", f);
fscanf(fptr,"%d\n", c);
for (i=0; i<*f; i++)
{
for (j=0; j<*c; j++)
{
fscanf(fptr,"%f", &m[i][j]);
}
}
fclose(fptr);
}
void imprimir_posiciones(float m[][DIM], int *f, int *c)
{
//imprime la matris de posiciones y la del campo electrico al
tener iguales dimensiones
int i, j;
for(i=0;i<*f;i++)
{
for(j=0;j<*c;j++)
{
printf("%.2ef ", m[i][j]);
}
printf("\n");
}
}

void imprimir_cargas(float m[][DIM+1], int *f, int *c)

{
//imprime la matris de cargas y sus posiciones ya que vinen
incluidas en una sola maris
int i, j;
for(i=0;i<*f;i++)
{
for(j=0;j<*c;j++)
{
printf("%.2ef ", m[i][j]);
}
printf("\n");
}
}

void inicializar_campoelectrico(int ce[][MAX], int *f, int *c)

{
int i, j;
for(i=0;i<*f;i++)
{
for(j=0;j<*c;j++)
{
ce[i][j]=0;
}
}
}

void campo_electrico(float ce[][DIM], float m[][DIM], float

n[][DIM+1], int *f, int *c, int *f1, int *c1)
{
/*la funcion calcula el campo electrico de todas las cargas
leidas en la matriz qr evaluadas
en cada punto de la matriz de posiciones*/
int i, j, k, l, o;
float aux[DIM], aux1[DIM], res[DIM], mod;
for(i=0;i<*f;i++)
{
 //se recorre las filas de la matris de posiciones
for(o=0;o<DIM;o++)
{
//se almacenan las posiciones en un vector axiliar
de 3 dimensiones
aux[o]=m[i][o];
}
for(k=0;k<*f1;k++)
{
//se recoore las fimas de la matris de cargas
for(l=0;l<DIM;l++)
{
//se almacena la posicion de una carga en un
vector auxiliar de 3 dimensiones
aux1[l]=n[k][l+1];
}
mod=0;
resta(aux, aux1, res);
modulo(res, &mod);
potencia(&mod, 3);
for(o=0;o<DIM;o++)
{
//esta linea de codigo calcula el campo electrico
para una carga y lo almacena en una matris

ce[i][o]=ce[i][o]+((1/(4*PI*E))*(n[k][0])*((res[o])/mod));
}
//como el valor de k aumenta se utilizara otra
carga evaluada en el mismo punto y su campo se sumara al anterior
}
}
}

void resta(float m[], float n[], float res[])

{
//esta funcion calcula una resta de vectores, dando como
resultado otro vector
int i;
for(i=0;i<DIM;i++)
{
//esta interaccion permite restar cada elemento de dos
vectores y almacenarlo en un vector
res[i]=m[i]-n[i];
}
}

void modulo(float v[], float *mod)

{
//como se permitio usar la libreria math.h calcula el modulo
de un vector que es un numero escalar
int i;
for(i=0;i<DIM;i++)
 {
//se calcula la suma de los cuadrados de los elementos
del vector
*mod=*mod+(v[i]*v[i]);
}
*mod=sqrt(*mod);//para obtener el modulo se usa la funcion
sqrt() para obtener una raiz real
}

void potencia(float *mod, int pot)

{
//calcula una potencia dependiendo del numero solicitado
int i;
float aux;
aux=1;
for(i=1;i<=pot;i++)
{
aux=aux*(*mod);
}
*mod=aux;
}