#include <gnome.h>
#include "cabecera.h"
extern GArray *numeros;
extern GArray *factores;
extern GArray *bases1, *bases2, *bases3, *bases4;
extern GArray *exponentes1, *exponentes2, *exponentes3, *exponentes4;
extern GArray *primos; 
extern GArray *RBASES; 
extern GArray *REXPON;
gint max_primo, num_factores;
extern gint num_primos;
gboolean primo=TRUE;
extern gint num_bases;
extern gint num_numeros;



void crea_arrays (gint num) 
{
gint temp=0;
numeros = g_array_new (TRUE, FALSE, sizeof (gint));
g_array_append_val (numeros, temp);

bases1 = g_array_new (TRUE, FALSE, sizeof (gint));
g_array_append_val (bases1, temp);
exponentes1 = g_array_new (TRUE, FALSE, sizeof (gint));
g_array_append_val (exponentes1, temp);

bases2 = g_array_new (TRUE, FALSE, sizeof (gint));
g_array_append_val (bases2, temp);
exponentes2 = g_array_new (TRUE, FALSE, sizeof (gint));
g_array_append_val (exponentes2, temp);

if (num>2)
    {
	bases3 = g_array_new (TRUE, FALSE, sizeof (gint));
	g_array_append_val (bases3, temp);
	exponentes3 = g_array_new (TRUE, FALSE, sizeof (gint));
	g_array_append_val (exponentes3, temp);
    }
if (num>3)
    {
	bases4 = g_array_new (TRUE, FALSE, sizeof (gint));
	g_array_append_val (bases4, temp);
	exponentes4 = g_array_new (TRUE, FALSE, sizeof (gint));
	g_array_append_val (exponentes4, temp);
    }

}

void libera_arrays(gint num)
{
	g_array_free (RBASES,TRUE);
	g_array_free (REXPON,TRUE);
	g_array_free (numeros,TRUE);
	g_array_free (primos,TRUE);
	g_array_free (factores,TRUE);
	g_array_free (bases1,TRUE);
	g_array_free (exponentes1,TRUE);
	g_array_free (bases2,TRUE);
	g_array_free (exponentes2,TRUE);
        if (num>2)
		{
		g_array_free (bases3,TRUE);
		g_array_free (exponentes3,TRUE);
		}
        if (num>3)
		{
		g_array_free (bases4,TRUE);
		g_array_free (exponentes4,TRUE);
		}


}


void bases_exponentes(GArray *factores, GArray *bases, GArray *exponentes)
{
gint i, temp;
num_bases=0;
for (i=1; i<=num_factores; i++)
    if (g_array_index(factores, gint, i) != g_array_index(factores, gint, i-1))
	{
	temp=g_array_index(factores, gint, i);
	g_array_append_val (bases, temp);
	num_bases++;
        temp=1;
	g_array_append_val (exponentes, temp);
	}
    else
	{
	temp = g_array_index(exponentes, gint, num_bases);   
        temp++;     
	g_array_remove_index (exponentes, num_bases);
	g_array_append_val (exponentes, temp);
	}
}

gboolean es_primo(gint numero)
{
primo=TRUE;
gint k;
for (k=1; k<=num_primos; k++)
    if (numero%g_array_index(primos, gint, k)==0) return FALSE;
return primo;
}

void lista_primos (gint numero)
{
gint temp=0, temp2=2;
primos = g_array_new (TRUE, FALSE, sizeof (gint));
g_array_append_val (primos, temp);
g_array_append_val (primos, temp2);

max_primo=2;
num_primos=1;
gint i;
for (i=3; i<=numero; i++) 
   if (es_primo(i)) 
        {  
	 g_array_append_val (primos, i);
	 max_primo=i;
	 num_primos=num_primos+1;
	}
}

void llena_factores (gint num)
{
  gint i, k, dividendo, temp=0;
  dividendo=num;
  k=1; 
  factores = g_array_new (TRUE, FALSE, sizeof (gint));
  g_array_append_val (factores, temp);
  num_factores=0;

         for (i=k; i<=num_primos; i++)
             if (dividendo==g_array_index(primos, gint, i)) 
		   {
                     	k=i;
			break;
		   }
  while (dividendo!=1)
	 if (dividendo%g_array_index(primos, gint, k)==0)   
	    {
            
	     g_array_append_val (factores, g_array_index(primos, gint, k));
             dividendo=dividendo/g_array_index(primos, gint, k);
	     num_factores++;
	    }
	else    k=k+1;

}


void bases_comunes()
{
gboolean igual=FALSE;
gint i,j,k,t, base;
gint temp=0;
RBASES = g_array_new (TRUE, FALSE, sizeof (gint));
g_array_append_val (RBASES, temp);
REXPON = g_array_new (TRUE, FALSE, sizeof (gint));
g_array_append_val (REXPON, temp);

for (i=1; i<bases1->len; i++)
  {
   base = g_array_index(bases1, gint, i);
   igual=FALSE;
   for (j=1; j<bases2->len; j++)
     if (base==g_array_index(bases2, gint, j))  
	switch (num_numeros)
          {
	    case 2: igual=TRUE;
		    break;
	    case 3: for (k=1; k<bases3->len; k++)
			if (base==g_array_index(bases3, gint, k))
			 	igual=TRUE;
		    break;
	    case 4: for (k=1; k<bases3->len; k++)
			if (base==g_array_index(bases3, gint, k))
			      for (t=1; t<bases4->len; t++)	
				if (base==g_array_index(bases4, gint, t))
					igual=TRUE;
		    break;

	  }	
   if (igual) g_array_append_val(RBASES, base);
  }
}

gint exp_menor(gint base)
{
gint i, minimo=1;
for (i=1; i<bases1->len; i++)    if (base==g_array_index(bases1, gint, i))
	minimo=g_array_index(exponentes1, gint, i);
for (i=1; i<bases2->len; i++)    if (base==g_array_index(bases2, gint, i))
	if (g_array_index(exponentes2, gint, i)<minimo) 
            minimo=g_array_index(exponentes2, gint, i);
if (num_numeros==3)
  for (i=1; i<bases3->len; i++)    if (base==g_array_index(bases3, gint, i))
	if (g_array_index(exponentes3, gint, i)<minimo) 
            minimo=g_array_index(exponentes3, gint, i);

if (num_numeros==4)
  for (i=1; i<bases4->len; i++)    if (base==g_array_index(bases4, gint, i))
	if (g_array_index(exponentes4, gint, i)<minimo) 
            minimo=g_array_index(exponentes4, gint, i);
return minimo;

}


void calculaMCD()
{
gint i, num;
bases_comunes();

for (i=1; i<RBASES->len; i++)
   {
   num=exp_menor(g_array_index(RBASES, gint, i));
   g_array_append_val(REXPON, num);
   }
}


void calculamcm()
{
gint i=0, j,k, maximo=1, base, cero;
RBASES = g_array_new (TRUE, FALSE, sizeof (gint));
g_array_append_val (RBASES, i);
REXPON = g_array_new (TRUE, FALSE, sizeof (gint));
g_array_append_val (REXPON, i);

for (i=1; i<bases1->len; i++)
    {
     j=g_array_index(bases1, gint, i);
     g_array_append_val(RBASES, j);
     j=g_array_index(exponentes1, gint, i);
     g_array_append_val(REXPON, j);
    }

for (i=1; i<bases2->len; i++)
    {
     j=g_array_index(bases2, gint, i);
     g_array_append_val(RBASES, j);
     j=g_array_index(exponentes2, gint, i);
     g_array_append_val(REXPON, j);
    }

if (num_numeros>=3)
  for (i=1; i<bases3->len; i++)
    {
     j=g_array_index(bases3, gint, i);
     g_array_append_val(RBASES, j);
     j=g_array_index(exponentes3, gint, i);
     g_array_append_val(REXPON, j);
    }

if (num_numeros==4)
  for (i=1; i<bases4->len; i++)
    {
     j=g_array_index(bases4, gint, i);
     g_array_append_val(RBASES, j);
     j=g_array_index(exponentes4, gint, i);
     g_array_append_val(REXPON, j);
    }

for (i=0; i<RBASES->len; i++)   
  {
   base=g_array_index(RBASES, gint, i);
   for (j=i+1; j<RBASES->len; j++)
      if (base==g_array_index(RBASES, gint, j))
         {
           maximo=g_array_index(REXPON, gint, i);
           if (maximo<g_array_index(REXPON, gint, j)) k=i;
		 else k=j;
	   g_array_remove_index (RBASES, k);
           cero=0;
	   g_array_insert_val(RBASES, k, cero);
         }
  }


for (i=RBASES->len-1; i>=1; i--)   
   if (g_array_index(RBASES, gint, i) == 0)
      {
	g_array_remove_index (RBASES, i);
	g_array_remove_index (REXPON, i);
      }

}

int num_digitos(int entero) 
{
if (entero>9999) return 5;
   else if (entero>999) return 4;
        else if (entero>99) return 3;
 	     else if (entero>9) return 2;
		  else return 1;
}