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

#include<iostream.h>
//using namespace std;

/* NOTA: en esta libreria incluye las siguientes funciones

int AnalisaSintaxis(char *)  -----> Analiza la sintaxis de la ecuacion y devuelve el valor del
                                    error y devuelve cero si no hay error

void ErrorEcuacion(int) ----->  Este se usa junto con AnalizaSintaxis te da el error de la ecuacion

EvaluarFuncion(char *, double) ----> Evalua una solo incognita en este caso 'x'

EvaluarFuncion(char *, double,double) ----> Evalua 2 incognitas en este caso 'x' e 'y'

y las funciones de derivada...(no pongo explicacion por q no se q onda)

*/

//-------------------------------------------------------------------------------------------
//---------- EVALUACION ECUACION --------------

int AnalizaSintaxis(char *pchrptrEcuacion)
{  /*lintI sirve como iterador para avanzar por la cadena*/
	/*lintParent sirve para contar los parentesis*/
	/*lintPunto sirve para contar los puntos decimales de un numero*/
	int lintI=0,lintParent=0;
	int lintPunto=0;
	/*lchrArrEcu sirve para almacenar nombres de funciones y compararlos*/
	char lchrArrEcu[10];
	if ((pchrptrEcuacion[0]=='^')||(pchrptrEcuacion[0]=='/')
		||(pchrptrEcuacion[0]=='*')||(pchrptrEcuacion[0]=='+'))
		{
			printf("%c ",pchrptrEcuacion[lintI]);
			return 2;
		}
	while(pchrptrEcuacion[lintI])
	{
		if(pchrptrEcuacion[lintI]==' ')
			return 8;
		if(pchrptrEcuacion[lintI]==')')
			if((pchrptrEcuacion[lintI+1]!='+')
			&&(pchrptrEcuacion[lintI+1]!='-')&&(pchrptrEcuacion[lintI+1]!='*')
			&&(pchrptrEcuacion[lintI+1]!='/')&&(pchrptrEcuacion[lintI+1]!=0)
			&&(pchrptrEcuacion[lintI+1]!=')')&&(pchrptrEcuacion[lintI+1]!='^'))

		  {
			printf("\nEl parentesis %c no tiene operador contiguo",pchrptrEcuacion[lintI]);
			return 9;
		  }
		if(isdigit(pchrptrEcuacion[lintI]))
			if((pchrptrEcuacion[lintI+1]!='+')
			&&(pchrptrEcuacion[lintI+1]!='-')&&(pchrptrEcuacion[lintI+1]!='*')
			&&(pchrptrEcuacion[lintI+1]!='/')&&(pchrptrEcuacion[lintI+1]!=0)
			&&(pchrptrEcuacion[lintI+1]!=')')&&(pchrptrEcuacion[lintI+1]!='.')

&&(pchrptrEcuacion[lintI+1]!='^')&&(!isdigit(pchrptrEcuacion[lintI+1])))

		  {
			printf("\nEl numero %c no tiene operador contiguo",pchrptrEcuacion[lintI]);
			return 9;
		  }
		if(pchrptrEcuacion[lintI]=='x'||(pchrptrEcuacion[lintI]=='y'))
			if((pchrptrEcuacion[lintI+1]!='+')
			&&(pchrptrEcuacion[lintI+1]!='-')&&(pchrptrEcuacion[lintI+1]!='*')
			&&(pchrptrEcuacion[lintI+1]!='/')&&(pchrptrEcuacion[lintI+1]!=0)
			&&(pchrptrEcuacion[lintI+1]!=')')&&(pchrptrEcuacion[lintI+1]!='^'))

		  {
			printf("\nEl numero %c no tiene operador contiguo",pchrptrEcuacion[lintI]);
			return 9;
		  }

		if(!isdigit(pchrptrEcuacion[lintI])&&(pchrptrEcuacion[lintI]!='+')
		&&(pchrptrEcuacion[lintI]!='-')&&(pchrptrEcuacion[lintI]!='*')
		&&(pchrptrEcuacion[lintI]!='/')&&(pchrptrEcuacion[lintI]!='(')
		&&(pchrptrEcuacion[lintI]!=')')&&(pchrptrEcuacion[lintI]!='.')
		&&(pchrptrEcuacion[lintI]!='x')&&(pchrptrEcuacion[lintI]!='y')
      &&(pchrptrEcuacion[lintI]!='^')
		)
			if(strlen(pchrptrEcuacion+lintI)>=3)
			{
			strncpy(lchrArrEcu,pchrptrEcuacion+lintI,3);
			lchrArrEcu[3]=0;
				if((!strcmp(lchrArrEcu,"sen"))||(!strcmp(lchrArrEcu,"cos"))
				||(!strcmp(lchrArrEcu,"tan"))||(!strcmp(lchrArrEcu,"ase"))
				||(!strcmp(lchrArrEcu,"aco"))||(!strcmp(lchrArrEcu,"ata"))
				||(!strcmp(lchrArrEcu,"log"))||(!strcmp(lchrArrEcu,"lgn"))
				||(!strcmp(lchrArrEcu,"exp"))||(!strcmp(lchrArrEcu,"ntc"))
				||(!strcmp(lchrArrEcu,"sec"))||(!strcmp(lchrArrEcu,"csc"))
				||(!strcmp(lchrArrEcu,"ctg"))||(!strcmp(lchrArrEcu,"act"))
				||(!strcmp(lchrArrEcu,"asc"))||(!strcmp(lchrArrEcu,"acs")))
				/*
				||(!strcmp(lchrArrEcu,"sen"))||(!strcmp(lchrArrEcu,"sen"))*/

				{
					if(pchrptrEcuacion[lintI+3]=='(')
							lintI+=3;
					else
					{
						printf("%s le falta inmediatamente ( ",lchrArrEcu);
						return 4;
					}

				}
				else
				{
				printf(" %s ",lchrArrEcu);
				return 6;
				}
			}
			else
			{
				printf("%c ",pchrptrEcuacion[lintI]);
				return 6;
			}
		if((pchrptrEcuacion[lintI]<40)
		||((pchrptrEcuacion[lintI]>57)&&(pchrptrEcuacion[lintI]<91))
		||(pchrptrEcuacion[lintI]==95)||(pchrptrEcuacion[lintI]==96)
		||(pchrptrEcuacion[lintI]>122))
		{
			printf("\n%c ",pchrptrEcuacion[lintI]);
			return 5;
		}
		else
		{
			if(pchrptrEcuacion[lintI]=='(')
			{
				lintParent++;
				if(pchrptrEcuacion[lintI+1]==')')
				{
					printf("\n() No hay argumentos dentro de los parentesis\n ");
					return 7;
				}
			}
			if(pchrptrEcuacion[lintI]==')')
			{
				if(lintParent>0)
					lintParent--;
				else
					return 1;
			}
			if((pchrptrEcuacion[lintI]=='+')||(pchrptrEcuacion[lintI]=='-')
			||(pchrptrEcuacion[lintI]=='*')||(pchrptrEcuacion[lintI]=='/')
			||(pchrptrEcuacion[lintI]=='^'))
				if((pchrptrEcuacion[lintI+1]==0)||(pchrptrEcuacion[lintI+1]=='+')
				||(pchrptrEcuacion[lintI+1]=='*')||(pchrptrEcuacion[lintI+1]=='/')
				||(pchrptrEcuacion[lintI+1]=='^')||(pchrptrEcuacion[lintI+1]==')'))
				{
					printf("\n%c%c \n",pchrptrEcuacion[lintI],pchrptrEcuacion[lintI+1]);
					return 2;
				}
		if(pchrptrEcuacion[lintI]=='.')//Conteo de puntos
			lintPunto++;
		if(lintPunto==2)
			return 3;
		if(!isdigit(pchrptrEcuacion[lintI])&&(pchrptrEcuacion[lintI]!='.'))
			lintPunto=0;//Anular puntos

		}
		lintI++;
	}

	if (!lintParent)
		return 0;
	else
		return 1;
}
/************Imprime los errores que se localizaron en la cadena*/
void ErrorEcuacion(int pintError)
{
	switch(pintError)
	{
		case 1: printf("Error %d: Falta,sobra ¢ parentesis mal acomodados",pintError);break;
		case 2: printf("Error %d: Le faltan argumentos al operador +,-,*,/ ¢ ^",pintError);break;
		case 3: printf("Error %d: No puede haber mas de un punto decimal",pintError);break;
		case 4: printf("Error %d: Le faltan parametros a la funcion ()",pintError);break;
		case 5: printf("Error %d: Simbolo invalido, escriba letras minusculas",pintError);break;
		case 6: printf("Error %d: Funcion Desconocida o puso espacios que no debe llevar",pintError);break;
		case 7: printf("Error %d: Necesita parametros dentro del parentesis",pintError);break;
		case 8: printf("Error %d: No ponga espacios en la ecuacion",pintError);break;
		default: printf("\nError desconocido\n");

	}
}
/*******Evalua la funcion a partir de una cadena*/
double EvaluarFuncion(char *pchrPtrEcuacion,double pfltValor)
{
		char lchrArrNumero[100];//Guarda la cadena Numero
		char lchrArrFuncion[10];//Guarda el nombre de funciones
		char lchrArrMiniEcuacion[50][100];//Separa en otras cadenas a traves de
		// operadores matematicos
		double lfltParcial=0;//Guarda el resultado
		int lintI=0,lintEcu=0,lintJ=0,lintAux=0;//Contadores
		for(lintI=0;lintI<50;lintI++)
			memset(lchrArrMiniEcuacion[lintI],0,99);//Limpiar miniEcuacion
		if(!pchrPtrEcuacion[0])
			return 0;
		if(!strcmp(pchrPtrEcuacion,"x"))
			return pfltValor;
		lintI=lintEcu=lintJ=lintAux=0;
		/********Inicia la separacion por sumas y restas */
	  while(pchrPtrEcuacion[lintI])
	  {
		lchrArrMiniEcuacion[lintEcu][lintJ]=pchrPtrEcuacion[lintI];
		if(pchrPtrEcuacion[lintI]=='(')
			lintAux++;
		if(pchrPtrEcuacion[lintI]==')')
			lintAux--;
		if((pchrPtrEcuacion[lintI]=='+')||(pchrPtrEcuacion[lintI]=='-'))
		{
			if(!lintAux)
			{

				lchrArrMiniEcuacion[lintEcu][lintJ]=0;
				lintEcu++;
				lintJ=-1;
			}

		}

		lintI++;
		lintJ++;
	  }
	  if(lintEcu)
	  {
		  lfltParcial=EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor);
		  lintI=lintEcu=lintJ=lintAux=0;
		  while(pchrPtrEcuacion[lintI])
		  {
			if(pchrPtrEcuacion[lintI]=='(')
				lintAux++;
			if(pchrPtrEcuacion[lintI]==')')
				lintAux--;
			if((pchrPtrEcuacion[lintI]=='+'))
				if(!lintAux)
				{

lfltParcial+=EvaluarFuncion(lchrArrMiniEcuacion[lintEcu+1],pfltValor);
					lintEcu++;
				}
			if((pchrPtrEcuacion[lintI]=='-'))
				if(!lintAux)
				{

lfltParcial-=EvaluarFuncion(lchrArrMiniEcuacion[lintEcu+1],pfltValor);
					lintEcu++;
				}

		lintI++;
		  }
		  if(lintEcu)
			return lfltParcial; // Conjunto de sumas
	  }
	  lintI=0;
	  for(lintI=0;lintI<50;lintI++)
		memset(lchrArrMiniEcuacion[lintI],0,99);//limpieza de miniEcuacion
	  lintEcu=lintAux=lintI=lintJ=0;
	  /**********Separacion por multiplicacion y division*/
	  while(pchrPtrEcuacion[lintI])
	  {
		lchrArrMiniEcuacion[lintEcu][lintJ]=pchrPtrEcuacion[lintI];
		if(pchrPtrEcuacion[lintI]=='(')
			lintAux++;
		if(pchrPtrEcuacion[lintI]==')')
			lintAux--;
		if((pchrPtrEcuacion[lintI]=='*')||(pchrPtrEcuacion[lintI]=='/'))
		{
			if(!lintAux)
			{
				lchrArrMiniEcuacion[lintEcu][lintJ]=0;
				lintEcu++;
				lintJ=-1;
			}

		}

		lintI++;
		lintJ++;
	  }
	  if(lintEcu)
	  {
		  lfltParcial=EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor);
		  lintI=lintEcu=lintJ=lintAux=0;
		  while(pchrPtrEcuacion[lintI])
		  {
			if(pchrPtrEcuacion[lintI]=='(')
				lintAux++;
			if(pchrPtrEcuacion[lintI]==')')
				lintAux--;
			if((pchrPtrEcuacion[lintI]=='*'))
			if(!lintAux)
				{

lfltParcial=lfltParcial*EvaluarFuncion(lchrArrMiniEcuacion[lintEcu+1],pfltValor);
					lintEcu++;
				}
			if((pchrPtrEcuacion[lintI]=='/'))
				if(!lintAux)
				{

lfltParcial=lfltParcial/EvaluarFuncion(lchrArrMiniEcuacion[lintEcu+1],pfltValor);
					lintEcu++;

				}

			lintI++;
		  }
		  if(lintEcu)
			return lfltParcial;
	  }
			 // Conjunto de Multiplicaciones
	  lintI=0;
	  for(lintI=0;lintI<50;lintI++)
		memset(lchrArrMiniEcuacion[lintI],0,99);//limpieza de miniEcuacion
	  lintEcu=lintAux=lintI=lintJ=0;
	  /**********Separacion por potencias*/
	  while(pchrPtrEcuacion[lintI])
	  {
		if(pchrPtrEcuacion[lintI]=='(')
			lintAux++;
		if(pchrPtrEcuacion[lintI]==')')
			lintAux--;
		if(pchrPtrEcuacion[lintI]=='^')
		{
			if(!lintAux)
			{
				lintI++;
				lintEcu++;
				lintJ=0;
			}

		}
		lchrArrMiniEcuacion[lintEcu][lintJ]=pchrPtrEcuacion[lintI];
		lintI++;
		lintJ++;
	  }
	  if(lintEcu)
	  {
		  lfltParcial=EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor);
		  lintI=lintEcu=lintJ=lintAux=0;
		  while(pchrPtrEcuacion[lintI])
		  {
			if(pchrPtrEcuacion[lintI]=='(')
				lintAux++;
			if(pchrPtrEcuacion[lintI]==')')
				lintAux--;
			if((pchrPtrEcuacion[lintI]=='^'))
			if(!lintAux)
				{

lfltParcial=pow(lfltParcial,EvaluarFuncion(lchrArrMiniEcuacion[lintEcu+1],pfltValor));
					lintEcu++;
				}
			lintI++;
		  }
		  if(lintEcu)
			return lfltParcial;
	  }
			 // Conjunto de potencias
	  /*******Descifrar numeros y funciones**/
	  lintI=0;
	  lfltParcial=1;

if(isdigit(pchrPtrEcuacion[lintI])||(pchrPtrEcuacion[lintI]=='.')||(pchrPtrEcuacion[lintI]=='x'))
	  {

while(isdigit(pchrPtrEcuacion[lintI])||(pchrPtrEcuacion[lintI]=='.')||(pchrPtrEcuacion[lintI]=='x'))
		  {

if((pchrPtrEcuacion[lintI]=='x')&&(lfltParcial)&&pchrPtrEcuacion[lintI+1]!='^')
				{
					lfltParcial=lfltParcial*pfltValor;
				}
				if((pchrPtrEcuacion[lintI]=='x')&&(!lfltParcial))
					lfltParcial=pfltValor;
				if(pchrPtrEcuacion[lintI]!='x')
				{
					lchrArrNumero[lintI]=pchrPtrEcuacion[lintI];
					lchrArrNumero[lintI+1]=0;

if((pchrPtrEcuacion[lintI+1]<'0')||((pchrPtrEcuacion[lintI+1]>'9')&&(pchrPtrEcuacion[lintI+1]!='.'))||(pchrPtrEcuacion[lintI+1]=='x')||(pchrPtrEcuacion[lintI+1]==0))
						lfltParcial=atof(lchrArrNumero);

				}
				lintI++;
		  }


		if(pchrPtrEcuacion[lintI]==0)
			return lfltParcial;
	  }
	  else
	  {

		if(strlen(pchrPtrEcuacion)>3)
		 {
			strncpy(lchrArrFuncion,pchrPtrEcuacion,3);
			lchrArrFuncion[3]=0;

			  if(!strcmp(lchrArrFuncion,"sen"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=sin(EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor));
					}
			  if(!strcmp(lchrArrFuncion,"cos"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=cos(EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor));
						}
			  if(!strcmp(lchrArrFuncion,"tan"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=tan(EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor));
					}
			  if(!strcmp(lchrArrFuncion,"ase"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=asin(EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor));
					}
			  if(!strcmp(lchrArrFuncion,"aco"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=acos(EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor));
					}
			  if(!strcmp(lchrArrFuncion,"ata"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=atan(EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor));
					}
			  if(!strcmp(lchrArrFuncion,"log"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=log10(EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor));
					}
			  if(!strcmp(lchrArrFuncion,"lgn"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=log(EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor));
					}
			  if(!strcmp(lchrArrFuncion,"exp"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=exp(EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor));
					}
			  if(!strcmp(lchrArrFuncion,"ntc"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=pow(10,EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor));
					}
			  if(!strcmp(lchrArrFuncion,"sec"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=1/cos(EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor));
					}
			  if(!strcmp(lchrArrFuncion,"csc"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=1/sin(EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor));
					}
			  if(!strcmp(lchrArrFuncion,"ctg"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=1/tan(EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor));
					}

			  if(!strcmp(lchrArrFuncion,"acs"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=asin(1/EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor));
					}
			  if(!strcmp(lchrArrFuncion,"asc"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=acos(1/EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor));
					}
			  if(!strcmp(lchrArrFuncion,"act"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=atan(1/EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor));
					}

		 }

		 if(pchrPtrEcuacion[lintI]=='(')
		 {
				lintAux++;
				lintI++;
				while(lintAux)
				{
				  if(pchrPtrEcuacion[lintI]=='(')
					lintAux++;
				  if(pchrPtrEcuacion[lintI]==')')
					lintAux--;
				  lchrArrMiniEcuacion[0][lintI-1]=pchrPtrEcuacion[lintI];
				  lintI++;
				}
				lchrArrMiniEcuacion[0][lintI-2]=0;
				lfltParcial=EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor);
		 }
	  }


	return lfltParcial;
}

//-------------------------------------------------------------------------------
//------------------ EVALUA FUNCION PARA 2 INCOGNITAS ---------------------------

double EvaluarFuncion(char *pchrPtrEcuacion,double pfltValor,double pfltValor1)
{
		char lchrArrNumero[100];//Guarda la cadena Numero
		char lchrArrFuncion[10];//Guarda el nombre de funciones
		char lchrArrMiniEcuacion[50][100];//Separa en otras cadenas a traves de
		// operadores matematicos
		double lfltParcial=0,lfltParcial1=0;//Guarda el resultado
		int lintI=0,lintEcu=0,lintJ=0,lintAux=0;//Contadores
		for(lintI=0;lintI<50;lintI++)
			memset(lchrArrMiniEcuacion[lintI],0,99);//Limpiar miniEcuacion
		if(!pchrPtrEcuacion[0])
			return 0;
		if(!strcmp(pchrPtrEcuacion,"x"))
			return pfltValor;
      if(!strcmp(pchrPtrEcuacion,"y"))
			return pfltValor1;
		lintI=lintEcu=lintJ=lintAux=0;
		/********Inicia la separacion por sumas y restas */
	  while(pchrPtrEcuacion[lintI])
	  {
		lchrArrMiniEcuacion[lintEcu][lintJ]=pchrPtrEcuacion[lintI];
		if(pchrPtrEcuacion[lintI]=='(')
			lintAux++;
		if(pchrPtrEcuacion[lintI]==')')
			lintAux--;
		if((pchrPtrEcuacion[lintI]=='+')||(pchrPtrEcuacion[lintI]=='-'))
		{
			if(!lintAux)
			{

				lchrArrMiniEcuacion[lintEcu][lintJ]=0;
				lintEcu++;
				lintJ=-1;
			}

		}

		lintI++;
		lintJ++;
	  }
	  if(lintEcu)
	  {
		  lfltParcial=EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor,pfltValor1);
		  lintI=lintEcu=lintJ=lintAux=0;
		  while(pchrPtrEcuacion[lintI])
		  {
			if(pchrPtrEcuacion[lintI]=='(')
				lintAux++;
			if(pchrPtrEcuacion[lintI]==')')
				lintAux--;
			if((pchrPtrEcuacion[lintI]=='+'))
				if(!lintAux)
				{

lfltParcial+=EvaluarFuncion(lchrArrMiniEcuacion[lintEcu+1],pfltValor,pfltValor1);
					lintEcu++;
				}
			if((pchrPtrEcuacion[lintI]=='-'))
				if(!lintAux)
				{

lfltParcial-=EvaluarFuncion(lchrArrMiniEcuacion[lintEcu+1],pfltValor,pfltValor1);
					lintEcu++;
				}

		lintI++;
		  }
		  if(lintEcu)
			return lfltParcial; // Conjunto de sumas
	  }
	  lintI=0;
	  for(lintI=0;lintI<50;lintI++)
		memset(lchrArrMiniEcuacion[lintI],0,99);//limpieza de miniEcuacion
	  lintEcu=lintAux=lintI=lintJ=0;
	  /**********Separacion por multiplicacion y division*/
	  while(pchrPtrEcuacion[lintI])
	  {
		lchrArrMiniEcuacion[lintEcu][lintJ]=pchrPtrEcuacion[lintI];
		if(pchrPtrEcuacion[lintI]=='(')
			lintAux++;
		if(pchrPtrEcuacion[lintI]==')')
			lintAux--;
		if((pchrPtrEcuacion[lintI]=='*')||(pchrPtrEcuacion[lintI]=='/'))
		{
			if(!lintAux)
			{
				lchrArrMiniEcuacion[lintEcu][lintJ]=0;
				lintEcu++;
				lintJ=-1;
			}

		}

		lintI++;
		lintJ++;
	  }
	  if(lintEcu)
	  {
		  lfltParcial=EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor,pfltValor1);
		  lintI=lintEcu=lintJ=lintAux=0;
		  while(pchrPtrEcuacion[lintI])
		  {
			if(pchrPtrEcuacion[lintI]=='(')
				lintAux++;
			if(pchrPtrEcuacion[lintI]==')')
				lintAux--;
			if((pchrPtrEcuacion[lintI]=='*'))
			if(!lintAux)
				{

lfltParcial=lfltParcial*EvaluarFuncion(lchrArrMiniEcuacion[lintEcu+1],pfltValor,pfltValor1);
					lintEcu++;
				}
			if((pchrPtrEcuacion[lintI]=='/'))
				if(!lintAux)
				{

lfltParcial=lfltParcial/EvaluarFuncion(lchrArrMiniEcuacion[lintEcu+1],pfltValor,pfltValor1);
					lintEcu++;

				}

			lintI++;
		  }
		  if(lintEcu)
			return lfltParcial;
	  }
			 // Conjunto de Multiplicaciones
	  lintI=0;
	  for(lintI=0;lintI<50;lintI++)
		memset(lchrArrMiniEcuacion[lintI],0,99);//limpieza de miniEcuacion
	  lintEcu=lintAux=lintI=lintJ=0;
	  /**********Separacion por potencias*/
	  while(pchrPtrEcuacion[lintI])
	  {
		if(pchrPtrEcuacion[lintI]=='(')
			lintAux++;
		if(pchrPtrEcuacion[lintI]==')')
			lintAux--;
		if(pchrPtrEcuacion[lintI]=='^')
		{
			if(!lintAux)
			{
				lintI++;
				lintEcu++;
				lintJ=0;
			}

		}
		lchrArrMiniEcuacion[lintEcu][lintJ]=pchrPtrEcuacion[lintI];
		lintI++;
		lintJ++;
	  }
	  if(lintEcu)
	  {
		  lfltParcial=EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor,pfltValor1);
		  lintI=lintEcu=lintJ=lintAux=0;
		  while(pchrPtrEcuacion[lintI])
		  {
			if(pchrPtrEcuacion[lintI]=='(')
				lintAux++;
			if(pchrPtrEcuacion[lintI]==')')
				lintAux--;
			if((pchrPtrEcuacion[lintI]=='^'))
			if(!lintAux)
				{

lfltParcial=pow(lfltParcial,EvaluarFuncion(lchrArrMiniEcuacion[lintEcu+1],pfltValor,pfltValor1));
					lintEcu++;
				}
			lintI++;
		  }
		  if(lintEcu)
			return lfltParcial;
	  }
			 // Conjunto de potencias
	  /*******Descifrar numeros y funciones**/
	  lintI=0;
	  lfltParcial=1;

if(isdigit(pchrPtrEcuacion[lintI])||(pchrPtrEcuacion[lintI]=='.')||(pchrPtrEcuacion[lintI]=='x')||(pchrPtrEcuacion[lintI]=='y'))
	  {

while(isdigit(pchrPtrEcuacion[lintI])||(pchrPtrEcuacion[lintI]=='.')||(pchrPtrEcuacion[lintI]=='x')||(pchrPtrEcuacion[lintI]=='y'))
		  {

if((pchrPtrEcuacion[lintI]=='x'||pchrPtrEcuacion[lintI]=='y')&&(lfltParcial)&&pchrPtrEcuacion[lintI+1]!='^')
				{
					lfltParcial=lfltParcial*pfltValor;
				}
				if((pchrPtrEcuacion[lintI]=='x')&&(!lfltParcial))
					lfltParcial=pfltValor;
            if((pchrPtrEcuacion[lintI]=='y')&&(!lfltParcial))
					lfltParcial=pfltValor1;
				if(pchrPtrEcuacion[lintI]!='x'||(pchrPtrEcuacion[lintI]=='y'))
				{
					lchrArrNumero[lintI]=pchrPtrEcuacion[lintI];
					lchrArrNumero[lintI+1]=0;

if((pchrPtrEcuacion[lintI+1]<'0')||((pchrPtrEcuacion[lintI+1]>'9')&&(pchrPtrEcuacion[lintI+1]!='.'))||(pchrPtrEcuacion[lintI+1]=='x')||(pchrPtrEcuacion[lintI]=='y')||(pchrPtrEcuacion[lintI+1]==0))
						lfltParcial=atof(lchrArrNumero);

				}
				lintI++;
		  }


		if(pchrPtrEcuacion[lintI]==0)
			return lfltParcial;
	  }
	  else
	  {

		if(strlen(pchrPtrEcuacion)>3)
		 {
			strncpy(lchrArrFuncion,pchrPtrEcuacion,3);
			lchrArrFuncion[3]=0;

			  if(!strcmp(lchrArrFuncion,"sen"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=sin(EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor,pfltValor1));
					}
			  if(!strcmp(lchrArrFuncion,"cos"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=cos(EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor,pfltValor1));
						}
			  if(!strcmp(lchrArrFuncion,"tan"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=tan(EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor,pfltValor1));
					}
			  if(!strcmp(lchrArrFuncion,"ase"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=asin(EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor,pfltValor1));
					}
			  if(!strcmp(lchrArrFuncion,"aco"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=acos(EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor,pfltValor1));
					}
			  if(!strcmp(lchrArrFuncion,"ata"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=atan(EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor,pfltValor1));
					}
			  if(!strcmp(lchrArrFuncion,"log"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=log10(EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor,pfltValor1));
					}
			  if(!strcmp(lchrArrFuncion,"lgn"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=log(EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor,pfltValor1));
					}
			  if(!strcmp(lchrArrFuncion,"exp"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=exp(EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor,pfltValor1));
					}
			  if(!strcmp(lchrArrFuncion,"ntc"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=pow(10,EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor,pfltValor1));
					}
			  if(!strcmp(lchrArrFuncion,"sec"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=1/cos(EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor,pfltValor1));
					}
			  if(!strcmp(lchrArrFuncion,"csc"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=1/sin(EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor,pfltValor1));
					}
			  if(!strcmp(lchrArrFuncion,"ctg"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=1/tan(EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor,pfltValor1));
					}

			  if(!strcmp(lchrArrFuncion,"acs"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=asin(1/EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor,pfltValor1));
					}
			  if(!strcmp(lchrArrFuncion,"asc"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=acos(1/EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor,pfltValor1));
					}
			  if(!strcmp(lchrArrFuncion,"act"))
					{
						strcpy(lchrArrMiniEcuacion[0],pchrPtrEcuacion+3);

lfltParcial=atan(1/EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor,pfltValor1));
					}

		 }

		 if(pchrPtrEcuacion[lintI]=='(')
		 {
				lintAux++;
				lintI++;
				while(lintAux)
				{
				  if(pchrPtrEcuacion[lintI]=='(')
					lintAux++;
				  if(pchrPtrEcuacion[lintI]==')')
					lintAux--;
				  lchrArrMiniEcuacion[0][lintI-1]=pchrPtrEcuacion[lintI];
				  lintI++;
				}
				lchrArrMiniEcuacion[0][lintI-2]=0;
				lfltParcial=EvaluarFuncion(lchrArrMiniEcuacion[0],pfltValor,pfltValor1);
		 }
	  }


	return lfltParcial;
}

//-------------------------------------------------------------------------------------------
//---------- EVALUACION DERIVADA --------------


/*void deriva(char *,char *);
float EvaluarConstante(char*,float);
int Analiza(char *);
int checaF(char *);
void chekpa(char *,char *aux);

void main()
{
  char ecuacion[100];
  char derivada[200];
  clrscr();
  cout<<"Reconocedor de Funciones para Derivar";
  cout<<"\nIngrese la funci¢n que desee derivar: ";
  cout<<"\n\nEjemplo: \t0.5*sen(x^2)+sin(x)";
  cout<<"\n\t\t3*x^2-5*x+1";
  cout<<"\n\nLas funciones matem ticas que se pueden reconocer al momento son:";
  cout<<"\nsen (SENO),       cos (COSENO),         tan (TANGENTE),     ase (ARC SEN),";
  cout<<"\nata (ARC TAN),    exp (EXPONENTE),      sec (SECANTE),      csc (COSECANTE),";
  cout<<"\nctg (COTANGENTE), act (ARC COTANGENTE), asc (ARCO SECANTE),";
  cout<<"\naco (ARC COS),    acs (ARC COSECANTE)";
  cout<<"\n\nNOTA: LOS CARACTERES DEBEN ESTAR EN MINUSCULAS, SOLO RECUELVE:";
  cout<<"\n      SOLO RECUELVE: dC/dx, dx/dx, u*x^n,";
  cout<<"\n\nFunciones trigonometricas ejemplo: sen(x), cos(x^2), sen(5*x^3+1)\npero no esta programado aun para funciones trigonomtricas que tengan (-) antes";
  cout<<"\n\nEjemplo: sen(x), cos(x^2), sen(5*x^3+1)\npero no esta programado para funciones trigonomtricas que tengan (-) antes";
  printf("\n\nEjemplo:  -sen(x),-coseno(x), etc");
  printf("\n\nEscriba la funci¢n que se debe derivar:  ");
  gets(ecuacion);
  if(Analiza(ecuacion))
    printf("\n Error");
  else
  {
    printf("\n Correcto\n");
    deriva(ecuacion,derivada);
    printf("\nLa derivada es %s",derivada);
    if(AnalizaSintaxis(derivada))
 printf("Error");
    else
 printf("Sintaxis correcta");
  }
  getch();
}*/

int checaF(char *original)
{
  //Verifica si la ecuacion es una constante
  int i=0;
  int deriv=0;
  while(original[i])
  {
    if(original[i]=='x')
      deriv++;
    i++;
  }
  if(deriv==0)
    return 0;
  else
    return 1;
}

void chekpa(char *original,char *aux)
{
  int i=0,parent=1;
  while(original[i+4])
  {
    aux[i]=original[i+4];
    if(original[i+4]=='(')
      parent++;
    if(original[i+4]==')')
      parent--;
    if(parent==0)
      aux[i]=0;
    i++;
  }
}
void deriva(char *original,char *derivada)
{
  int i=0,k=0,l=0;//i itera original k y l iteran aux
  int oper=0;
  int parent=0;
  double real=0;
  char aux[50][50];//sirve para guardar fragmentos de suma derivadas
  char derivas[50];
  if(original[0]==0)
    return ;
  if(!strcmp(original,"x"))
  {
    sprintf(derivada,"1");
    return ;
  }
  if(checaF(original)==0)
  {
    sprintf(derivada,"0");
    return ;
  }
  //separador de ecuaciones por suma y resta
  while(original[i])
  {
    aux[k][l]=original[i];
    if(original[i]=='(')
      parent++;
    if(original[i]==')')
      parent-- ;
    if((original[i]=='+')||(original[i]=='-'))
      if(!parent)
      {
 aux[k][l]=0;
 oper++;
 k++;
 l=-1;
 if(original[i]=='-')
 {
   aux[k][0]='-';
   l=0;
 }
      }
    i++;
    l++;
  }
  aux[k][l]=0;
  i=0;
  if(oper)
  {
    while(i<=oper)
    {
      deriva(aux[i],derivas);
      if(i==0)
 sprintf(derivada,"%s",derivas);
      else
      {
 if(derivas[0]=='-')
   sprintf(derivada+strlen(derivada),"%s",derivas);
 else
   sprintf(derivada+strlen(derivada),"+%s",derivas);
      }
      i++;
    }
    return ;
  }
  //separacion por funciones
  strncpy(aux[0],original,3);
  aux[0][3]=0;
  parent=1;
  if(!strcmp(aux[0],"exp"))
  {
    chekpa(original,aux[1]);
    deriva(aux[1],derivas);
    sprintf(derivada,"exp(%s)*(%s)",aux[1],derivas);
    return ;
  }
  //derivar una funcion trigonometrica
  if(!strcmp(aux[0],"sen"))
  {
    chekpa(original,aux[1]);
    deriva(aux[1],derivas);
    sprintf(derivada,"cos(%s)*(%s)",aux[1],derivas);
    return ;
  }
  if(!strcmp(aux[0],"cos"))
  {
    chekpa(original,aux[1]);
    deriva(aux[1],derivas);
    sprintf(derivada,"-sen(%s)*(%s)",aux[1],derivas);
    return ;
  }
  if(!strcmp(aux[0],"tan"))
  {
    chekpa(original,aux[1]);
    deriva(aux[1],derivas);
    sprintf(derivada,"(sec(%s))^2*(%s)",aux[1],derivas);
    return ;
  }
  if(!strcmp(aux[0],"ctg"))
  {
    chekpa(original,aux[1]);
    deriva(aux[1],derivas);
    sprintf(derivada,"-((csc(%s))^2)*(%s)",aux[1],derivas);
    return ;
  }
  if(!strcmp(aux[0],"sec"))
  {
    chekpa(original,aux[1]);
    deriva(aux[1],derivas);
    sprintf(derivada,"sec(%s)*tan(%s)*(%s)",aux[1],aux[1],derivas);
    return ;
  }
  if(!strcmp(aux[0],"csc"))
  {
    chekpa(original,aux[1]);
    deriva(aux[1],derivas);
    sprintf(derivada,"-(csc(%s)*cot(%s)*(%s))",aux[1],aux[1],derivas);
    return ;
  }
  if(!strcmp(aux[0],"ase"))
  {
    chekpa(original,aux[1]);
    deriva(aux[1],derivas);
    sprintf(derivada,"(%s)/((1-(%s))^(.5))",derivas,aux[1]);
    return ;
  }
  if(!strcmp(aux[0],"aco"))
  {
    chekpa(original,aux[1]);
    deriva(aux[1],derivas);
    sprintf(derivada,"-(%s/((1-(%s))^(.5)))",derivas,aux[1]);
    return ;
  }
  if(!strcmp(aux[0],"ata"))
  {
    chekpa(original,aux[1]);
    deriva(aux[1],derivas);
    sprintf(derivada,"(%s)/(1+(%s)^2)",derivas,aux[1]);
    return ;
  }
  if(!strcmp(aux[0],"act"))
  {
    chekpa(original,aux[1]);
    deriva(aux[1],derivas);
    sprintf(derivada,"-((%s)/(1+(%s)^2))",derivas,aux[1]);
    return ;
  }
  if(!strcmp(aux[0],"asc"))
  {
    chekpa(original,aux[1]);
    deriva(aux[1],derivas);

sprintf(derivada,"(%s)/((%s)*((((%s)^2)-1)^(.5)))",derivas,aux[1],aux[1]);
    return ;
  }
  if(!strcmp(aux[0],"acs"))
  {
    chekpa(original,aux[1]);
    deriva(aux[1],derivas);

sprintf(derivada,"-(%s)/((%s)*((((%s)^2)-1)^(.5)))",derivas,aux[1],aux[1]);
    return ;
  }
  i=0;k=0;l=0;oper=0;
  //Derivar una constante con una x con potencia
  while(original[i])
  {
    if(original[0]=='x')
      strcpy(aux[0],"1");
    if(original[i]=='x')
    {
      if(original[i+1]!='^')
 strcpy(aux[1],"1");
    }
    if(original[i]=='^')
      oper++;
    if((isdigit(original[i]))||(original[i])=='.')
    {
      if(!oper)
      {
 aux[0][l]=original[i];
 l++;
 aux[0][l]=0;
      }
      else
      {
 aux[1][k]=original[i];
 k++;
 aux[1][k]=0;
      }
    }
    i++;
  }
  real=atof(aux[0])*atof(aux[1]);
  if(atof(aux[1])==2.)
    sprintf(derivada,"%.2f*(x)",real);
  else
  {
    if(atof(aux[1]-1)==0.)
      sprintf(derivada,"%.2f",real);
    if(atof(aux[1])>2.0)
      sprintf(derivada,"%.2f*(x^(%.2f))",real,atof(aux[1])-1);
  }
  return ;
}



int Analiza(char *ecuacion)
{
  /*i sirve como iterador para avanzar por la cadena
  parentesis sirve para contar los parentesis
  punto sirve para contar los puntos decimales de un numero*/
  int i=0,parentesis=0;
  int punto=0;
  /*ecu sirve para almacenar nombres de funciones y compararlos*/
  char ecu[10];
  if((ecuacion[0]=='^')||(ecuacion[0]=='/')
    ||(ecuacion[0]=='*')||(ecuacion[0]=='+'))
  {
    printf("%c ",ecuacion[i]);
    return 2;
  }
  while(ecuacion[i])
  {
    if(ecuacion[i]==' ')
      return 8;
    if(!isdigit(ecuacion[i])&&(ecuacion[i]!='+')
 &&(ecuacion[i]!='-')&&(ecuacion[i]!='*')
 &&(ecuacion[i]!='/')&&(ecuacion[i]!='(')
 &&(ecuacion[i]!=')')&&(ecuacion[i]!='.')
 &&(ecuacion[i]!='x')&&(ecuacion[i]!='^'))
      if(strlen(ecuacion+i)>=3)
      {
 strncpy(ecu,ecuacion+i,3);
 ecu[3]=0;
 if((!strcmp(ecu,"sen"))||(!strcmp(ecu,"cos"))
  ||(!strcmp(ecu,"tan"))||(!strcmp(ecu,"ase"))
  ||(!strcmp(ecu,"aco"))||(!strcmp(ecu,"ata"))
  ||(!strcmp(ecu,"log"))||(!strcmp(ecu,"lgn"))
  ||(!strcmp(ecu,"exp"))||(!strcmp(ecu,"ntc"))
  ||(!strcmp(ecu,"sec"))||(!strcmp(ecu,"csc"))
  ||(!strcmp(ecu,"ctg"))||(!strcmp(ecu,"act"))
  ||(!strcmp(ecu,"asc"))||(!strcmp(ecu,"acs")))
 {
   if(ecuacion[i+3]=='(')
     i+=3;
   else
   {
     printf("%s le falta inmediatamente ( ",ecu);
     return 4;
   }
 }
 else
 {
   printf(" %s ",ecu);
   return 6;
 }
      }
      else
      {
 printf("%c ",ecuacion[i]);
 return 6;
      }
      if((ecuacion[i]<40)||((ecuacion[i]>57)&&(ecuacion[i]<91))
      ||(ecuacion[i]==95)||(ecuacion[i]==96)||(ecuacion[i]>122))
      {
 printf("\n%c ",ecuacion[i]);
 return 5;
      }
      else
      {
 if(ecuacion[i]=='(')
 {
   parentesis++;
   if(ecuacion[i+1]==')')
   {
     printf("\n() No hay argumentos dentro de los parentesis\n ");
     return 7;
   }
 }
 if(ecuacion[i]==')')
 {
   if(parentesis>0)
     parentesis--;
   else
     return 1;
 }
 if((ecuacion[i]=='+')||(ecuacion[i]=='-')||(ecuacion[i]=='*')
  ||(ecuacion[i]=='/')||(ecuacion[i]=='^'))
   if((ecuacion[i+1]==0)||(ecuacion[i+1]=='+')||(ecuacion[i+1]=='*')
    ||(ecuacion[i+1]=='/')||(ecuacion[i+1]=='^')||(ecuacion[i+1]==')'))
   {
     printf("\n%c%c \n ",ecuacion[i],ecuacion[i+1]);
     return 2;
   }
   if(ecuacion[i]=='.')//Conteo de puntos
     punto++;
   if(punto==2)
     return 3;
   if(!isdigit(ecuacion[i])&&(ecuacion[i]!='.'))
     punto=0;//Anular puntos
      }
      i++;
  }
  if (!parentesis)
    return 0;
  else
    return 1;
}