elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Rompecabezas de Bitcoin, Medio millón USD en premios


  Mostrar Temas
Páginas: [1]
1  Programación / Programación C/C++ / Conversor de numeros decimales a binario con punto decimal basico en: 15 Septiembre 2013, 06:21 am
Hola bien dia a todos ya he pedido ayuda varia veces con buenos resultados, en este caso tengo que hacer un conversor de numeros binarios pero lo quiero hacer basico sin usar arreglos, y metiendo cantidades por separado, por ejemplo 123.34 : primero meter 123 y despues 34 generando en un resultado mi idea es asi y por cierto esperi su ayuda para poder hacer la parte que va despues del punto por que no se como hacerlo (para tomar el numero 0 o 1 al multiplicar por dos), y al imprimir la primera parte ya que al dividir no imprime un digito , espero su ayuda gracias:



Código
  1. #include<iostream>
  2.  
  3. using std::cout;
  4. using std::cin;
  5. using std::endl;
  6.  
  7. int main()
  8. {
  9.     int i,i1,d,d1,cosi,cosi1,rest1,rest;
  10.  
  11.  
  12.     cout<<"\n Conversor de numeros decimales a bibario"<<endl;
  13.     cout<<"\n Introduce un numero antes del punto"<<endl;
  14.     cin>>d;
  15.     cout<<"\n Introduce un numero despues del punto"<<endl;
  16.     cin>>d1;
  17.     cout<<"\n El numero binario es:"<<endl;
  18.  
  19.  /*   for(;i1<=d1;)//for para el numero despues del punto 
  20. {
  21.     cosi1=d1*2;
  22.     d1=cosi1;
  23.     rest1=cosi1%2;
  24.     cout<<rest1<<endl;
  25.     
  26. }
  27.     */
  28.     //for para antes del punto
  29.     for(/*i=1*/;i<=d;)
  30. {
  31.     cosi=d/2;
  32.     d=cosi;
  33.     rest=cosi%2;
  34.     cout<<rest<<endl;
  35.  
  36. }
  37.  
  38.  
  39.  
  40.     system("PAUSE");
  41.     return 0;
  42. }
  43.  
2  Programación / Programación C/C++ / No entiendo nada ! de arboles "AVL" en: 11 Mayo 2013, 20:39 pm
Hey hola ya he recibido ayuda de ustedes y de nuevo vengo para eso , resulta que no entiendo un nada un código que mi profe me ha proporcionado, es acerca de los arboles(arboles AVL) y sus rotaciones por medio de listas, pero no le entiendo al código amigos ya me han dicho que es algo arcaico y tiene su complejidad, lo que quisiera saber es como funciona el código y en especial la fucnion de "Rotar a la izquierda" y la de "Insert" y el "main" (como esta estructurado) espero contar con su ayuda, dejo el código es "C"

Código
  1. #include <conio.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <ctype.h>
  5.  
  6. typedef struct node
  7. {
  8.    int num, bal;
  9.    struct node *izq, *der;
  10. }node;
  11.  
  12. typedef node *ptr;
  13.  
  14. void rota_izq(ptr *pp)
  15. {
  16.    ptr p=*pp, r;
  17.    *pp=r=p->der;
  18.    p->der=r->izq;
  19.    r->izq=p;
  20.    p->bal--;
  21.    if(r->bal > 0)
  22.       p->bal -= r->bal;
  23.    r->bal--;
  24.    if(p->bal < 0)
  25.       r->bal += p->bal;
  26. }
  27.  
  28. void rota_der(ptr * pp)
  29. {
  30.    ptr p=*pp, l;
  31.    *pp = l = p->izq;
  32.    p->izq = l->der;
  33.    l->der = p;
  34.    p->bal++;
  35.    if(l->bal < 0)
  36.       p->bal -= l->bal;
  37.    l->bal++;
  38.    if(p->bal > 0)
  39.       l->bal += p->bal;
  40. }
  41.  
  42. int insert(ptr *pp, int x)
  43. {
  44.    int deltaH=0;
  45.    ptr p=*pp;
  46.    if(p == NULL)
  47.    {
  48.       *pp = p = (ptr)malloc(sizeof(node));
  49.       if(p==NULL)
  50. 	 puts("Not enough memory"), exit(1);
  51.       p->num = x;
  52.       p->bal=0;
  53.       p->izq = p->der = NULL;
  54.       deltaH = 1;
  55.    }
  56.    else
  57.       if(x > p->num)
  58.       {
  59. 	 if(insert(&p->der, x))
  60. 	 {
  61. 	    p->bal++;
  62. 	    if(p->bal == 1)
  63. 	       deltaH=1;
  64. 	    else
  65. 	       if(p->bal ==2)
  66. 	       {
  67. 		  if(p->der->bal == -1)
  68. 		     rota_der(&p->der);
  69. 		  rota_izq(pp);
  70. 	       }
  71. 	 }
  72.       }
  73.       else
  74. 	 if(x < p->num)
  75. 	 {
  76. 	    if(insert(&p->izq, x))
  77. 	    {
  78. 	       p->bal--;
  79. 	       if(p->bal == -1)
  80. 		  deltaH= 1;
  81. 	       else
  82. 		  if(p->bal == -2)
  83. 		  {
  84. 		     if(p->izq->bal == 1)
  85. 			rota_izq(&p->izq);
  86. 		     rota_der(pp);
  87. 		  }
  88. 	    }
  89. 	 }
  90. 	 return deltaH;
  91. }
  92.  
  93. int delnode(ptr *pp, int x)
  94. {
  95.    ptr p=*pp, *qq;
  96.    int deltaH = 0;
  97.    if(p==NULL)
  98.       return 0;
  99.    if(x < p->num)
  100.    {
  101.       if(delnode(&p->izq, x))
  102.       {
  103. 	 p->bal++;
  104. 	 if(p->bal == 0)
  105. 	    deltaH=1;
  106. 	 else
  107. 	    if(p->bal==2)
  108. 	    {
  109. 	       if(p->der->bal == -1)
  110. 		  rota_der(&p->der);
  111. 	       rota_izq(pp);
  112. 	       if(p->bal == 0)
  113. 		  deltaH=1;
  114. 	    }
  115.       }
  116.    }
  117.    else
  118.       if(x>p->num)
  119.       {
  120. 	 if(delnode(&p->der, x))
  121. 	 {
  122. 	    p->bal--;
  123. 	    if(p->bal ==0)
  124. 	       deltaH=1;
  125. 	    else
  126. 	       if(p->bal == -2)
  127. 	       {
  128. 		  if(p->izq->bal ==1)
  129. 		     rota_izq(&p->izq);
  130. 		  rota_der(pp);
  131. 		  if(p->bal == 0)
  132. 		     deltaH = 1;
  133. 	       }
  134. 	 }
  135.       }
  136.       else
  137.       {
  138. 	 if(p->der == NULL)
  139. 	 {
  140. 	    *pp = p->izq;
  141. 	    free(p);
  142. 	    return 1;
  143. 	 }
  144. 	 else
  145. 	    if(p->izq == NULL)
  146. 	    {
  147. 	       *pp = p->der;
  148. 	       free(p);
  149. 	       return 1;
  150. 	    }
  151. 	    else
  152. 	    {
  153. 	       qq = &p->izq;
  154. 	       while((*qq)->der != NULL)
  155. 		  qq = &(*qq)->der;
  156. 	       p->num=(*qq)->num;
  157. 	       (*qq)->num=x;
  158. 	       if(delnode(&p->izq, x))
  159. 	       {
  160. 		  p->bal++;
  161. 		  if(p->bal == 0)
  162. 		     deltaH = 1;
  163. 		  else
  164. 		     if(p->bal ==2)
  165. 		     {
  166. 			if(p->der->bal == -1)
  167. 			   rota_der(&p->der);
  168. 			rota_izq(pp);
  169. 			deltaH=1;
  170. 		     }
  171. 	       }
  172. 	 }
  173.    }
  174.    return deltaH;
  175. }
  176.  
  177. void printtree(node *p, int pos)
  178. {
  179.    if(p != NULL)
  180.    {
  181.       printtree(p->der, pos+6);
  182.       printf("%*d %d\n", pos, p->num, p->bal);
  183.       printtree(p->izq, pos+6);
  184.    }
  185. }
  186.  
  187. main()
  188. {
  189.    int x;
  190.    char ch;
  191.    node *root = NULL;
  192.  
  193.    clrscr();
  194.    puts("\nCada arbol AVL presentado en el problema tiene\n"
  195. 	"su raiz en la izq. Girela 90 grados\n"
  196. 	"en el sentido del reloj para obtener su representacion usual\n");
  197.    for(;;)
  198.    {
  199.       printf("Digite un entero, seguido de I para insertar\n"
  200. 	     "o por D para borrar, o Q para salir: ");
  201.       if(scanf("%d %c",&x, &ch) != 2)
  202. 	 break;
  203.       ch = toupper(ch);
  204.       if(ch == 'I')
  205. 	 insert(&root, x);
  206.       else
  207. 	 if(ch == 'D')
  208. 	    delnode(&root, x);
  209.       printtree(root, 6);
  210.    }
  211.    return 0;
  212. }
  213.  
  214.  
3  Programación / Programación C/C++ / Menú con funciones, no se si lo esta haciendo bien. en: 10 Marzo 2013, 09:00 am
Hola muchachos es la segunda vez que pido ayuda emm tengo un problema? , bueno no he entendido del todo el tema de los nodos y estructuras en c (mi profe no domina el tema, y quiere que le entendamos a la primera), puesto que me han dejado un código incompleto el cual he tratado de terminar bueno principalmente me enfoco a que tengo que desarrollar una rutina de generar la función seno y senh-1  pero al ejecutar mi programa no se si estén correctos los valores que este muestra solicito su colaboración para ver si lo que he estado haciendo esta bien, no entiendo el tema espero me ayuden muchas gracias de antemano .
Anexo el código para que lo chequen :







Código
  1. /* PROGRAMA: SUMA, RESTA, MULTIPLICACION Y DIVISION DE POLINOMIOS */
  2. # include <stdio.h>
  3. # include <stdlib.h>
  4. # include <alloc.h>
  5. # include <conio.h>
  6. # include <dos.h>
  7. # include <string.h>
  8.  
  9. # include <math.h>
  10.  
  11. # define DELAY 64000
  12.  
  13. struct apuntador
  14. {
  15. 	float coef;
  16. 	int exp1;
  17. 	struct apuntador *siguiente;
  18. } nodo;
  19.  
  20. struct apuntador
  21. 	*polydat1, *polydat2, *polysum1, *polysum2, *polysuma, *polymin,
  22. 	*polysus, *polyres, *polyfac1, *polyfac2, *polyprod, *polynum,
  23. 	*polyden, *polycos, *polyresta, *polyresul, *aux_poly, *nuevo,
  24. 	*polyder;
  25.  
  26. 	void pausa(void), crea(void), iniciapoly(void),
  27. 		presentacion(void),
  28. 		insert_lista(struct apuntador **poly, float c, int e),
  29. 		imprime(struct apuntador *poly),
  30. 		suma_poly(struct apuntador *poly1, struct apuntador *poly2,
  31. 						struct apuntador **poly3),
  32. 		multy_poly(struct apuntador *poly1, struct apuntador *poly2,
  33. 						struct apuntador **poly3),
  34. 		resta_poly(struct apuntador *poly1, struct apuntador *poly2,
  35. 						struct apuntador **poly3),
  36. 		div_poly(struct apuntador *poly1, struct apuntador *poly2,
  37. 			 struct apuntador **poly3, struct apuntador **poly4),
  38. 		der_poly(struct apuntador *poly1, struct apuntador **poly3),
  39. 		borrar_poly(struct apuntador **poly3, int e);
  40. 		float eval_poly(struct apuntador *poly1,float x);
  41. 		float factorial(int);
  42.  
  43.  
  44. int seleccion_menu(void);
  45. 	int i,caso,e;
  46. 	float c,epsilon;
  47. 	float coef;
  48. 	int exp1,fx,x0;  // SE CAMBIA EXP SOLO AQUI O EN TODOS?
  49. 	char n;
  50. 	int opcion;
  51.  
  52. main()
  53. {
  54.   presentacion();
  55.   clrscr();
  56.   for(;;)
  57. 	 {
  58. 		switch(seleccion_menu())
  59. 	{
  60.  
  61.  
  62. 	  case 1:
  63. 	  int limite, iter=0;
  64. 	  float fxd,epsilon,xa,xn;
  65. 	  clrscr();
  66. 	  printf("\n Metodo de Newton Raphson (RAICES) de poly1");
  67. 	  printf("\n Dame el valor inicial de x0    para poly1 ==>");
  68. 	  scanf("%f",&x0);
  69. 	  printf("\n Dame el Epsilon ==>");
  70. 	  scanf("%f",&epsilon);
  71. 	  printf("\n Dame el nuemro maximo de iteraciones ==>");
  72. 	  scanf("%d",&limite);
  73. 	  der_poly(polydat1, &polyder);
  74. 	  printf("\n #iter----x0----------fx----------fxd----------xn");
  75. 	  do
  76. 		{
  77. 		 xa=x0;
  78. 		 fx=eval_poly(polydat1,xa);
  79. 		 fxd=eval_poly(polyder,xa);
  80. 		 xn=xa - fx/fxd;
  81. 		 iter=iter+1;
  82. 		 printf("\n %d   %f   %f   %f   %f",iter,xa,fx,fxd,xn);
  83. 		 x0=xn;
  84. 		} while((fabs(xa-xn)>epsilon)&&(iter<=limite));
  85. 	  printf("\n el valor final de x es = 5f",xn);
  86. 	  printf("\n\n");
  87. 	  pausa();
  88. 	  pausa();
  89. 	  pausa();
  90. 	  break;
  91.  
  92.  
  93. 	  case 2:
  94. 		clrscr();  
  95.         iniciapoly();
  96. 		do
  97. 		  {     do
  98. 			  {
  99. 				 printf("\n Dame el valor del coeficiente del poly 1 ==> ");
  100. 				 scanf("%f",&c);
  101. 				} while (c == 0);
  102.  
  103. 				 printf("\n Dame el valor del exponente del poly 1   ==> ");
  104. 			scanf("%d",&e);
  105. 			insert_lista(&polydat1,c,e);
  106. 			printf("\n Desea otro termino (s/n) ? ==> ");
  107. 			opcion=getche();
  108. 		  }  while((opcion==115) || (opcion==83));
  109. 		  imprime(polydat1);
  110. 		  printf("\n\n");
  111. 		  do
  112. 			 {
  113. 			do
  114. 			  {
  115. 				 printf("\n Dame el valor del coeficiente del poly 2 ==> ");
  116. 				 scanf("%f",&c);
  117. 				} while (c == 0);
  118. 				 printf("\n Dame el valor del exponente de poly 2    ==> ");
  119. 			scanf("%d",&e);
  120. 			insert_lista(&polydat2,c,e);
  121. 			printf("\n Desea otro termino (s/n) ? ==> ");
  122. 			opcion=getche();
  123. 			 }  while((opcion==115) || (opcion==83));
  124. 			 imprime(polydat2);
  125. 			 pausa();
  126. 			 break;
  127. 	  case 3:
  128. 		polysum1=polydat1;
  129. 		polysum2=polydat2;
  130. 		suma_poly(polysum1,polysum2,&polysuma);
  131. 		imprime(polysuma);
  132. 		pausa();
  133. 		break;
  134. 	  case 4:
  135. 		polyfac1=polydat1;
  136. 		polyfac2=polydat2;
  137. 		multy_poly(polyfac1,polyfac2,&polyprod);
  138. 		imprime(polyprod);
  139. 		pausa();
  140. 		break;
  141. 	  case 5:
  142. 		polymin=polydat1;
  143. 		polysus=polydat2;
  144. 		resta_poly(polymin,polysus,&polyresta);
  145. 		imprime(polyresta);
  146. 		pausa();
  147. 		break;
  148. 	  case 6:
  149. 		polyder = polydat1;
  150. 		der_poly(polydat1,&polyder);
  151. 		printf("Derivada:\n");
  152. 		imprime(polyder);
  153. 		pausa();
  154. 		break;
  155. 	  case 7:
  156. 		printf("\ Fin del Programa");
  157. 		exit(0);
  158. 		default:
  159. 		printf("\n Operacion no valida");
  160. 		//return (0);
  161.  
  162. 	  case 8:
  163. 		fx=eval_poly(polydat1,x0);
  164. 		break;
  165. 	  case 9:
  166.  
  167. 		break;
  168. 	  case 10:
  169. 		clrscr();
  170. 		printf("\n Dame el valor del exponente del termino a borrar de poly1 ==> ");
  171. 		scanf("%d",&e);
  172. 		borrar_poly(&polydat1,e);
  173. 		imprime(polydat1);
  174. 		printf("\n\n");
  175. 		pausa();
  176. 		break;
  177.  
  178.  
  179.  
  180. 	  case 11:
  181. 		struct apuntador *fx;
  182. 		fx=polydat1;
  183. 		float a,b,c,it_limit,fa,fb,fc;
  184. 		int it=0;
  185. 		while(1)
  186. 		{//0
  187. 		 clrscr();
  188. 		 printf("\n Metodo de la biseccion (PARA RAICES) de poly1");
  189. 		 printf("\n dar la cota inferior a = ?");
  190. 		 scanf("%f",&a);
  191. 		 printf("\n dar la cota superior b = ?");
  192. 		 scanf("%f",&b);
  193. 		 printf("\n Dar el epsilon ==> ?");
  194. 		 scanf("%f",&epsilon);
  195. 		 printf("\n Dar el limite de iteraciones =? ");
  196. 		 scanf("%f",&it_limit);
  197. 		 printf("\n It.--a-----b-----c-----f(a)-----f(c)-----abs(f(c)-f(a))/2");
  198. 		 fa= eval_poly(fx,a);
  199. 		 fb= eval_poly(fx,b);
  200. 		 if((fa*fb)>0)
  201. 		  {//1
  202. 			printf("\n La solucion no esta entre a..b ya que f(a) f(b)>0 \n");
  203. 		  } //-1
  204. 		 else
  205. 		  while(1)
  206. 			{//2
  207. 			 it=it+1;
  208. 			 c=(a+b)/2;
  209. 			 fc=eval_poly(fx,c);
  210. 			 printf("\n %3d  %10.6f  %10.6f  %10.6f  %10.6f  %10.6f",it,a,c,b,fa,fc);
  211. 			 printf("\n %14.8f \n",fabs((fb-fa)/2));
  212. 			 pausa();
  213. 			 if(it>it_limit)
  214. 			 break;
  215. 			 if(fabs(c-a)<epsilon)
  216. 			 break;
  217. 			 if(fa*fc<=0)
  218. 			  { b=c; fb=fc; }
  219. 			 else
  220. 			  { a=c; fa=fc; }
  221. 			}//-2
  222. 		 if(it<=it_limit)
  223. 		  printf("\n Tolerancia satisfecha");
  224. 		 if(it>it_limit)
  225. 		  printf("\n limite exedido de iteraciones");
  226. 		  printf("\n el resultado final de x es =%g \n",c);
  227. 		  printf("\n\n");
  228.  
  229. 		  pausa();
  230. 		  pausa();
  231. 	  }//0
  232. 		break;
  233.  
  234. 		case 12:
  235. 		 struct apuntador *fsen=NULL;
  236. 		 int t,expo,signo;
  237. 		 double coefi,x,ter;
  238. 		 double suma=0;
  239. 		 double vfsen;
  240. 		 clrscr();
  241. 		 printf("\n Dar el valor de terminos: ");
  242. 		 scanf("%d",&t);
  243. 		 printf("\n Dar el valor de X: ");
  244. 		 scanf("%f",&x);
  245. 		 x=x*3.1416/180;
  246. 		 printf("\n #ter sig  exp    coefi        ter         suma");
  247. 		 for(int ni=0;ni<t;ni++)
  248. 		  {
  249. 			signo=pow(-1,ni);
  250. 			expo=2*ni+1;
  251. 			coefi=signo/factorial(expo);
  252. 			insert_lista(&fsen,coefi,expo);
  253. 			ter=coefi*pow(x,expo);
  254. 			suma=suma+ter;
  255. 			printf("\n\n %2d   %2d   %2d  %10.8f  %10.8f  %10.8f",ni+1,signo,expo,coefi,ter,suma);
  256. 		  }
  257. 		 printf("\n\n\n El valor sel seno con sumatoria es : %14.12f\n\n",suma);
  258. 		 getche();
  259. 		 imprime(fsen);
  260. 		 vfsen=eval_poly(fsen,x);
  261. 		 printf("\n\n El valor del seno con polinomio es : %14.12f",vfsen);
  262. 		 getche();
  263. 		 polydat1=fsen;
  264. 		 printf("\n\n");
  265. 		 pausa();
  266. 		break;
  267.  
  268. 	case 13:
  269. 		 struct apuntador *fsinhmu=NULL;
  270.  
  271.          int te,expon,sign;
  272. 		 double coefic,xi,termin,dn;
  273. 		 double sumas=0;
  274. 		 double vfsinhmu;
  275.  
  276.          clrscr();
  277. 		 printf("\n Dar el valor de terminos: ");
  278. 		 scanf("%d",&te);
  279. 		 printf("\n Dar el valor de X: ");
  280. 		 scanf("%f",&xi);
  281. 		 xi=xi*3.1416/180;
  282. 		 printf("\n #Term Signo  Exp   Coeficiente   Termino      Suma");
  283. 		 for(int n=0;n<te;n++)
  284. 		  {
  285. 			sign=pow(-1,n);
  286. 			expon=2*n+1;
  287. 			dn=2*n;
  288. 			coefic=(sign*factorial(dn))/(pow(4,n)*pow(factorial(n),2)*expon);
  289. 			insert_lista(&fsinhmu,coefic,expon);
  290. 			termin=coefic*pow(xi,expon);
  291. 			sumas=sumas+termin;
  292. 			printf("\n\n   %2d    %2d   %2d    %10.8f   %10.8f   %10.8f",n+1,sign,expon,coefic,termin,sumas);
  293. 		  }
  294. 		 printf("\n\n\n El valor sel seno con sumatoria es : %14.12f\n\n",sumas);
  295. 		 getche();
  296. 		 imprime(fsinhmu);
  297. 		 vfsinhmu=eval_poly(fsinhmu,xi);
  298. 		 printf("\n\n El valor del seno con polinomio es : %14.12f",vfsinhmu);
  299. 		 getche();
  300. 		 polydat1=fsinhmu;
  301. 		 printf("\n\n");
  302. 		 pausa();
  303. 		break;
  304.  
  305. 	}
  306. 	}
  307. }
  308.  
  309. seleccion_menu(void)
  310. {
  311. 	char s[80];
  312. 	int x;
  313. 	clrscr();
  314. 	printf("\n\n          OPERACIONES DE POLINOMIOS:");
  315. 	printf("\n\n\n             1 ) Metodo de Newton Rhapson \n");
  316. 	printf("                   2 ) Crear polinomio. \n");
  317. 	printf("                   3 ) Suma. \n");
  318. 	printf("                   4 ) Multiplicacion. \n");
  319. 	printf("                   5 ) Resta. \n");
  320. 	printf("                   6 ) Derivada. \n");
  321. 	printf("                   7 ) Salir. \n");
  322. 	printf("                   8 ) Evaluar polyn(x). \n");
  323. 	printf("                   9 ) Modificar termino de polinomio.\n");
  324. 	printf("                   10 ) Borrar algun termino. \n");
  325. 	printf("                   11 )  Metodo de Biseccion \n");
  326. 	printf("                   12 )  Genera funcion Seno de Taylor \n");
  327. 	printf("                   13 )  Genera funcion SenoHyperbolico Inverso \n");
  328. 	do
  329. 	{
  330. 		printf("                                   OPCION ==> ");
  331. 		gets(s);
  332. 		x=atoi(s);
  333. 	}  while (x<0 || x>14);
  334. 	return (x);
  335. }
  336.  
  337. void pausa(void)
  338. {
  339. 	printf("\n Pulsar cualquier tecla para continuar...");
  340. 	getch();
  341. }
  342.  
  343. void iniciapoly(void)
  344. {
  345. 	polydat1=NULL;
  346. 	polydat2=NULL;
  347. 	polysum1=NULL;
  348. 	polysum2=NULL;
  349. 	polysuma=NULL;
  350. 	polymin=NULL;
  351. 	polysus=NULL;
  352. 	polyres=NULL;
  353. 	polyfac1=NULL;
  354. 	polyfac2=NULL;
  355. 	polyprod=NULL;
  356. 	polynum=NULL;
  357. 	polyden=NULL;
  358. 	polycos=NULL;
  359. 	polyres=NULL;
  360. 	polyresta=NULL;
  361. 	polyder=NULL;
  362. }
  363.  
  364. void insert_lista(struct apuntador **poly, float coefi, int expo)
  365. { //0
  366. 	struct apuntador *nuevo, *aux,*ant;
  367. 	int band=0;
  368. 	nuevo=(struct apuntador *) malloc (sizeof(nodo));
  369. 	if(nuevo == NULL)
  370. 	{//1
  371. 		printf("MEMORIA AGOTADA \n");
  372. 		return;
  373. 	}//-1
  374. 	nuevo->coef=coefi;
  375. 	nuevo->exp1=expo;
  376. 	nuevo->siguiente=NULL;
  377. 	if(*poly==NULL)
  378. 		*poly=nuevo;
  379. 	else
  380. 	{//-2
  381. 		aux=*poly;
  382. 		if(aux->exp1 < expo)
  383. 		{ //3
  384. 			nuevo->siguiente=*poly;
  385. 			*poly=nuevo;
  386. 		}//-3
  387. 		else //EN OTRSOS CASOS
  388. 		{//4
  389. 		 while((aux)&&(band))
  390. 		  {//5
  391. 			 if(aux->exp1==expo)
  392. 			  {//6 PARA TERMINO CON IGUAL EXPONENTE
  393. 				aux->coef=aux->coef+coefi;
  394. 				delete(nuevo); // O ES "if(aux->coef==0)"
  395. 				band=1;
  396. 			  }//-6
  397. 			 else //PARA EL CASO: aux->exp1>expo
  398. 			  {//7
  399. 				if((aux->siguiente!= NULL)&&(expo>aux->siguiente->exp1))
  400. 				 {//8
  401. 				  nuevo->siguiente=aux->siguiente;
  402. 				  aux->siguiente=nuevo;
  403. 				  band=1;
  404. 				 }//-8
  405. 				else
  406. 				 {//9
  407. 				  if(aux->siguiente==NULL)
  408. 					{//10
  409. 					 aux->siguiente=nuevo;
  410. 					 band=1;
  411. 					}//-10
  412. 				  else
  413. 					ant=aux;
  414. 					aux=aux->siguiente;
  415. 				 }//-9
  416. 			  }//-7
  417. 		  }//-5
  418. 		}//-4
  419. 	}
  420. }//-0
  421.  
  422. void imprime(struct apuntador *poly)
  423. {
  424. 	while(poly)
  425. 	{
  426. 		printf("\n\n Coeficiente : %f \n",poly->coef);
  427. 		printf(" Exponente   : %i",poly->exp1);
  428. 		poly=poly->siguiente;
  429. 	}
  430. }
  431.  
  432. void suma_poly(struct apuntador *poly1, struct apuntador *poly2,
  433. 		struct apuntador **poly3)
  434. {
  435. 	float suma;
  436. 	struct apuntador *primero;
  437. 	primero = NULL;
  438. 	suma=0;
  439. 	while((poly1 != NULL) && (poly2 != NULL))
  440. 	{
  441. 		if (poly1->exp1 == poly2-> exp1)
  442. 		{
  443. 			suma=poly1->coef + poly2->coef;
  444. 			if(suma !=0)
  445. 			{
  446. 				insert_lista(&primero,suma,poly1->exp1);
  447. 			}
  448. 			poly1=poly1->siguiente;
  449. 			poly2=poly2->siguiente;
  450. 		}
  451. 		else
  452. 			if(poly1->exp1 > poly2->exp1)
  453. 			{
  454. 				insert_lista(&primero,poly1->coef,poly1->exp1);
  455. 				poly1=poly1->siguiente;
  456. 			}
  457. 			else
  458. 			{
  459. 				insert_lista(&primero,poly2->coef,poly2->exp1);
  460. 				poly2=poly2->siguiente;
  461. 			}
  462. 			suma=0;
  463. 	}
  464. 	while(poly1 != NULL)
  465. 	{
  466. 		insert_lista(&primero,poly1->coef,poly1->exp1);
  467. 		poly1=poly1->siguiente;
  468. 	}
  469. 	while(poly2 != NULL)
  470. 	{
  471. 		insert_lista(&primero,poly2->coef,poly2->exp1);
  472. 		poly2=poly2->siguiente;
  473. 	}
  474. 	*poly3 = primero;
  475. }
  476.  
  477. void multy_poly(struct apuntador *poly1, struct apuntador *poly2,
  478. 		struct apuntador **poly3)
  479. {
  480. 	struct apuntador *primero;
  481. 	float multy;
  482. 	int sum;
  483. 	struct apuntador *p, *q, *aux1, *aux2;
  484.  
  485. 	primero = NULL;
  486. 	*poly3=NULL;
  487. 	multy=1;
  488. 	sum=0;
  489. 	while(poly2 != NULL)
  490. 		{
  491. 			p=poly1;
  492. 			while(p!=NULL)
  493. 			{
  494. 				multy=p->coef *poly2->coef;
  495. 				sum=p->exp1 + poly2->exp1;
  496. 				if(multy != 0)
  497. 				{
  498. 					insert_lista(&primero,multy,sum);
  499. 					p=p->siguiente;
  500. 				}
  501. 				else
  502. 				{
  503. 					insert_lista(&primero,p->coef,p->exp1);
  504. 					p=p->siguiente;
  505. 					poly2=poly2->siguiente;
  506. 				}
  507. 				multy=1;
  508. 			}
  509. 			poly2=poly2->siguiente;
  510. 		}
  511. 		q = primero;
  512. 		while(q)
  513. 		{
  514. 			if(q->exp1==q->siguiente->exp1)
  515. 			{
  516. 				q->coef=q->coef + q->siguiente->coef;
  517. 				q->siguiente=q->siguiente->siguiente;
  518. 			}
  519. 			else
  520. 				q=q->siguiente;
  521. 		}
  522. 		*poly3=primero;
  523. }
  524.  
  525. void resta_poly(struct apuntador *poly1, struct apuntador *poly2,
  526. 		struct apuntador **poly3)
  527. {
  528.     float resta;
  529.     struct apuntador *primero;
  530. 	 primero = NULL;
  531. 	 resta= 0;
  532.     while ((poly1 != NULL) && (poly2 != NULL))
  533. 		 {
  534. 	  if (poly1->exp1 == poly2->exp1)
  535. 		 {
  536. 			resta= poly1->coef - poly2->coef;
  537. 			if (resta != 0) {
  538. 		 insert_lista (&primero, resta, poly1->exp1); }
  539. 			poly1= poly1->siguiente;
  540. 			poly2= poly2->siguiente;
  541. 		 }
  542. 	  else
  543. 		 if (poly1->exp1 > poly2->exp1)
  544. 			{
  545. 			 insert_lista (&primero, poly1->coef, poly1->exp1);
  546. 			 poly1= poly1->siguiente;
  547. 			}
  548. 		 else
  549. 			{
  550. 			 insert_lista (&primero, poly2->coef, poly2->exp1);
  551. 			 poly2= poly2->siguiente;
  552. 			}
  553. 	resta= 0;
  554. 	 }
  555.  
  556. 	 while (poly1 != NULL)
  557. 		{
  558. 		insert_lista (&primero, poly1->coef, poly1->exp1);
  559. 		poly1= poly1->siguiente;
  560. 		}
  561.  
  562.     while (poly2 != NULL)
  563. 		{
  564. 		insert_lista (&primero, -poly2->coef, poly2->exp1);
  565. 	   poly2= poly2->siguiente;
  566. 		}
  567.       *poly3 = primero;
  568. }
  569.  
  570. void borrar_poly(struct apuntador **poly, int expo)
  571. {
  572. // aqui va el codigo correspondiente
  573. }
  574.  
  575. void div_poly(struct apuntador *polynume, struct apuntador *polydeno,
  576. 		struct apuntador **polycoci, struct apuntador **polyresi)
  577. {
  578.  
  579. }
  580.  
  581. void der_poly(struct apuntador *poly1,struct apuntador **poly3)
  582. {
  583.  struct apuntador *primero=NULL;
  584.  float co=0;
  585.  int ex=0;
  586.   while((poly1!=NULL)&&(poly1->exp1!=0))
  587. 	{
  588. 	 co=poly1->coef*poly1->exp1;
  589. 	 ex=poly1->exp1-1;
  590. 	 insert_lista(&primero,co,ex);
  591. 	 poly1=poly1->siguiente;
  592. 	}
  593. }
  594.  
  595. float eval_poly(struct apuntador *poly1, float ev)
  596.  {
  597.   float res2;
  598.   res2=0;
  599.   while(poly1)
  600. 	{
  601. 	 res2=res2+poly1->coef*pow(ev,poly1->exp1);
  602. 	 poly1=poly1->siguiente;
  603. 	}
  604. 	return (res2);
  605.  }
  606.  
  607. void presentacion(void)
  608. {
  609. 	char c[1];
  610. 	clrscr();
  611. 	printf("\n\n                      PROGRAMA POLINOMIO \n\n");
  612. 	printf("          REALIZA LA SUMA, RESTA, MULTIPLICACION Y DIVISION \n\n");
  613.  
  614. }
  615.  
  616. float factorial(int n)
  617.   {
  618.    int k;
  619.    float f=1;
  620.    for(k=1;k<=n;k++)
  621.       f=f*k;
  622.    return(f);
  623.   }
  624. /* PROGRAMA: SUMA, RESTA, MULTIPLICACION Y DIVISION DE POLINOMIOS */
  625. # include <stdio.h>
  626. # include <stdlib.h>
  627. # include <alloc.h>
  628. # include <conio.h>
  629. # include <dos.h>
  630. # include <string.h>
  631.  
  632. # include <math.h>
  633.  
  634. # define DELAY 64000
  635.  
  636. struct apuntador
  637. {
  638. 	float coef;
  639. 	int exp1;
  640. 	struct apuntador *siguiente;
  641. } nodo;
  642.  
  643. struct apuntador
  644. 	*polydat1, *polydat2, *polysum1, *polysum2, *polysuma, *polymin,
  645. 	*polysus, *polyres, *polyfac1, *polyfac2, *polyprod, *polynum,
  646. 	*polyden, *polycos, *polyresta, *polyresul, *aux_poly, *nuevo,
  647. 	*polyder;
  648.  
  649. 	void pausa(void), crea(void), iniciapoly(void),
  650. 		presentacion(void),
  651. 		insert_lista(struct apuntador **poly, float c, int e),
  652. 		imprime(struct apuntador *poly),
  653. 		suma_poly(struct apuntador *poly1, struct apuntador *poly2,
  654. 						struct apuntador **poly3),
  655. 		multy_poly(struct apuntador *poly1, struct apuntador *poly2,
  656. 						struct apuntador **poly3),
  657. 		resta_poly(struct apuntador *poly1, struct apuntador *poly2,
  658. 						struct apuntador **poly3),
  659. 		div_poly(struct apuntador *poly1, struct apuntador *poly2,
  660. 			 struct apuntador **poly3, struct apuntador **poly4),
  661. 		der_poly(struct apuntador *poly1, struct apuntador **poly3),
  662. 		borrar_poly(struct apuntador **poly3, int e);
  663. 		float eval_poly(struct apuntador *poly1,float x);
  664. 		float factorial(int);
  665.  
  666.  
  667. int seleccion_menu(void);
  668. 	int i,caso,e;
  669. 	float c,epsilon;
  670. 	float coef;
  671. 	int exp1,fx,x0;  // SE CAMBIA EXP SOLO AQUI O EN TODOS?
  672. 	char n;
  673. 	int opcion;
  674.  
  675. main()
  676. {
  677.   presentacion();
  678.   clrscr();
  679.   for(;;)
  680. 	 {
  681. 		switch(seleccion_menu())
  682. 	{
  683.  
  684.  
  685. 	  case 1:
  686. 	  int limite, iter=0;
  687. 	  float fxd,epsilon,xa,xn;
  688. 	  clrscr();
  689. 	  printf("\n Metodo de Newton Raphson (RAICES) de poly1");
  690. 	  printf("\n Dame el valor inicial de x0    para poly1 ==>");
  691. 	  scanf("%f",&x0);
  692. 	  printf("\n Dame el Epsilon ==>");
  693. 	  scanf("%f",&epsilon);
  694. 	  printf("\n Dame el nuemro maximo de iteraciones ==>");
  695. 	  scanf("%d",&limite);
  696. 	  der_poly(polydat1, &polyder);
  697. 	  printf("\n #iter----x0----------fx----------fxd----------xn");
  698. 	  do
  699. 		{
  700. 		 xa=x0;
  701. 		 fx=eval_poly(polydat1,xa);
  702. 		 fxd=eval_poly(polyder,xa);
  703. 		 xn=xa - fx/fxd;
  704. 		 iter=iter+1;
  705. 		 printf("\n %d   %f   %f   %f   %f",iter,xa,fx,fxd,xn);
  706. 		 x0=xn;
  707. 		} while((fabs(xa-xn)>epsilon)&&(iter<=limite));
  708. 	  printf("\n el valor final de x es = 5f",xn);
  709. 	  printf("\n\n");
  710. 	  pausa();
  711. 	  pausa();
  712. 	  pausa();
  713. 	  break;
  714.  
  715.  
  716. 	  case 2:
  717. 		clrscr();  
  718.         iniciapoly();
  719. 		do
  720. 		  {     do
  721. 			  {
  722. 				 printf("\n Dame el valor del coeficiente del poly 1 ==> ");
  723. 				 scanf("%f",&c);
  724. 				} while (c == 0);
  725.  
  726. 				 printf("\n Dame el valor del exponente del poly 1   ==> ");
  727. 			scanf("%d",&e);
  728. 			insert_lista(&polydat1,c,e);
  729. 			printf("\n Desea otro termino (s/n) ? ==> ");
  730. 			opcion=getche();
  731. 		  }  while((opcion==115) || (opcion==83));
  732. 		  imprime(polydat1);
  733. 		  printf("\n\n");
  734. 		  do
  735. 			 {
  736. 			do
  737. 			  {
  738. 				 printf("\n Dame el valor del coeficiente del poly 2 ==> ");
  739. 				 scanf("%f",&c);
  740. 				} while (c == 0);
  741. 				 printf("\n Dame el valor del exponente de poly 2    ==> ");
  742. 			scanf("%d",&e);
  743. 			insert_lista(&polydat2,c,e);
  744. 			printf("\n Desea otro termino (s/n) ? ==> ");
  745. 			opcion=getche();
  746. 			 }  while((opcion==115) || (opcion==83));
  747. 			 imprime(polydat2);
  748. 			 pausa();
  749. 			 break;
  750. 	  case 3:
  751. 		polysum1=polydat1;
  752. 		polysum2=polydat2;
  753. 		suma_poly(polysum1,polysum2,&polysuma);
  754. 		imprime(polysuma);
  755. 		pausa();
  756. 		break;
  757. 	  case 4:
  758. 		polyfac1=polydat1;
  759. 		polyfac2=polydat2;
  760. 		multy_poly(polyfac1,polyfac2,&polyprod);
  761. 		imprime(polyprod);
  762. 		pausa();
  763. 		break;
  764. 	  case 5:
  765. 		polymin=polydat1;
  766. 		polysus=polydat2;
  767. 		resta_poly(polymin,polysus,&polyresta);
  768. 		imprime(polyresta);
  769. 		pausa();
  770. 		break;
  771. 	  case 6:
  772. 		polyder = polydat1;
  773. 		der_poly(polydat1,&polyder);
  774. 		printf("Derivada:\n");
  775. 		imprime(polyder);
  776. 		pausa();
  777. 		break;
  778. 	  case 7:
  779. 		printf("\ Fin del Programa");
  780. 		exit(0);
  781. 		default:
  782. 		printf("\n Operacion no valida");
  783. 		//return (0);
  784.  
  785. 	  case 8:
  786. 		fx=eval_poly(polydat1,x0);
  787. 		break;
  788. 	  case 9:
  789.  
  790. 		break;
  791. 	  case 10:
  792. 		clrscr();
  793. 		printf("\n Dame el valor del exponente del termino a borrar de poly1 ==> ");
  794. 		scanf("%d",&e);
  795. 		borrar_poly(&polydat1,e);
  796. 		imprime(polydat1);
  797. 		printf("\n\n");
  798. 		pausa();
  799. 		break;
  800.  
  801.  
  802.  
  803. 	  case 11:
  804. 		struct apuntador *fx;
  805. 		fx=polydat1;
  806. 		float a,b,c,it_limit,fa,fb,fc;
  807. 		int it=0;
  808. 		while(1)
  809. 		{//0
  810. 		 clrscr();
  811. 		 printf("\n Metodo de la biseccion (PARA RAICES) de poly1");
  812. 		 printf("\n dar la cota inferior a = ?");
  813. 		 scanf("%f",&a);
  814. 		 printf("\n dar la cota superior b = ?");
  815. 		 scanf("%f",&b);
  816. 		 printf("\n Dar el epsilon ==> ?");
  817. 		 scanf("%f",&epsilon);
  818. 		 printf("\n Dar el limite de iteraciones =? ");
  819. 		 scanf("%f",&it_limit);
  820. 		 printf("\n It.--a-----b-----c-----f(a)-----f(c)-----abs(f(c)-f(a))/2");
  821. 		 fa= eval_poly(fx,a);
  822. 		 fb= eval_poly(fx,b);
  823. 		 if((fa*fb)>0)
  824. 		  {//1
  825. 			printf("\n La solucion no esta entre a..b ya que f(a) f(b)>0 \n");
  826. 		  } //-1
  827. 		 else
  828. 		  while(1)
  829. 			{//2
  830. 			 it=it+1;
  831. 			 c=(a+b)/2;
  832. 			 fc=eval_poly(fx,c);
  833. 			 printf("\n %3d  %10.6f  %10.6f  %10.6f  %10.6f  %10.6f",it,a,c,b,fa,fc);
  834. 			 printf("\n %14.8f \n",fabs((fb-fa)/2));
  835. 			 pausa();
  836. 			 if(it>it_limit)
  837. 			 break;
  838. 			 if(fabs(c-a)<epsilon)
  839. 			 break;
  840. 			 if(fa*fc<=0)
  841. 			  { b=c; fb=fc; }
  842. 			 else
  843. 			  { a=c; fa=fc; }
  844. 			}//-2
  845. 		 if(it<=it_limit)
  846. 		  printf("\n Tolerancia satisfecha");
  847. 		 if(it>it_limit)
  848. 		  printf("\n limite exedido de iteraciones");
  849. 		  printf("\n el resultado final de x es =%g \n",c);
  850. 		  printf("\n\n");
  851.  
  852. 		  pausa();
  853. 		  pausa();
  854. 	  }//0
  855. 		break;
  856.  
  857. 		case 12:
  858. 		 struct apuntador *fsen=NULL;
  859. 		 int t,expo,signo;
  860. 		 double coefi,x,ter;
  861. 		 double suma=0;
  862. 		 double vfsen;
  863. 		 clrscr();
  864. 		 printf("\n Dar el valor de terminos: ");
  865. 		 scanf("%d",&t);
  866. 		 printf("\n Dar el valor de X: ");
  867. 		 scanf("%f",&x);
  868. 		 x=x*3.1416/180;
  869. 		 printf("\n #ter sig  exp    coefi        ter         suma");
  870. 		 for(int ni=0;ni<t;ni++)
  871. 		  {
  872. 			signo=pow(-1,ni);
  873. 			expo=2*ni+1;
  874. 			coefi=signo/factorial(expo);
  875. 			insert_lista(&fsen,coefi,expo);
  876. 			ter=coefi*pow(x,expo);
  877. 			suma=suma+ter;
  878. 			printf("\n\n %2d   %2d   %2d  %10.8f  %10.8f  %10.8f",ni+1,signo,expo,coefi,ter,suma);
  879. 		  }
  880. 		 printf("\n\n\n El valor sel seno con sumatoria es : %14.12f\n\n",suma);
  881. 		 getche();
  882. 		 imprime(fsen);
  883. 		 vfsen=eval_poly(fsen,x);
  884. 		 printf("\n\n El valor del seno con polinomio es : %14.12f",vfsen);
  885. 		 getche();
  886. 		 polydat1=fsen;
  887. 		 printf("\n\n");
  888. 		 pausa();
  889. 		break;
  890.  
  891. 	case 13:
  892. 		 struct apuntador *fsinhmu=NULL;
  893.  
  894.          int te,expon,sign;
  895. 		 double coefic,xi,termin,dn;
  896. 		 double sumas=0;
  897. 		 double vfsinhmu;
  898.  
  899.          clrscr();
  900. 		 printf("\n Dar el valor de terminos: ");
  901. 		 scanf("%d",&te);
  902. 		 printf("\n Dar el valor de X: ");
  903. 		 scanf("%f",&xi);
  904. 		 xi=xi*3.1416/180;
  905. 		 printf("\n #Term Signo  Exp   Coeficiente   Termino      Suma");
  906. 		 for(int n=0;n<te;n++)
  907. 		  {
  908. 			sign=pow(-1,n);
  909. 			expon=2*n+1;
  910. 			dn=2*n;
  911. 			coefic=(sign*factorial(dn))/(pow(4,n)*pow(factorial(n),2)*expon);
  912. 			insert_lista(&fsinhmu,coefic,expon);
  913. 			termin=coefic*pow(xi,expon);
  914. 			sumas=sumas+termin;
  915. 			printf("\n\n   %2d    %2d   %2d    %10.8f   %10.8f   %10.8f",n+1,sign,expon,coefic,termin,sumas);
  916. 		  }
  917. 		 printf("\n\n\n El valor sel seno con sumatoria es : %14.12f\n\n",sumas);
  918. 		 getche();
  919. 		 imprime(fsinhmu);
  920. 		 vfsinhmu=eval_poly(fsinhmu,xi);
  921. 		 printf("\n\n El valor del seno con polinomio es : %14.12f",vfsinhmu);
  922. 		 getche();
  923. 		 polydat1=fsinhmu;
  924. 		 printf("\n\n");
  925. 		 pausa();
  926. 		break;
  927.  
  928. 	}
  929. 	}
  930. }
  931.  
  932. seleccion_menu(void)
  933. {
  934. 	char s[80];
  935. 	int x;
  936. 	clrscr();
  937. 	printf("\n\n          OPERACIONES DE POLINOMIOS:");
  938. 	printf("\n\n\n             1 ) Metodo de Newton Rhapson \n");
  939. 	printf("                   2 ) Crear polinomio. \n");
  940. 	printf("                   3 ) Suma. \n");
  941. 	printf("                   4 ) Multiplicacion. \n");
  942. 	printf("                   5 ) Resta. \n");
  943. 	printf("                   6 ) Derivada. \n");
  944. 	printf("                   7 ) Salir. \n");
  945. 	printf("                   8 ) Evaluar polyn(x). \n");
  946. 	printf("                   9 ) Modificar termino de polinomio.\n");
  947. 	printf("                   10 ) Borrar algun termino. \n");
  948. 	printf("                   11 )  Metodo de Biseccion \n");
  949. 	printf("                   12 )  Genera funcion Seno de Taylor \n");
  950. 	printf("                   13 )  Genera funcion SenoHyperbolico Inverso \n");
  951. 	do
  952. 	{
  953. 		printf("                                   OPCION ==> ");
  954. 		gets(s);
  955. 		x=atoi(s);
  956. 	}  while (x<0 || x>14);
  957. 	return (x);
  958. }
  959.  
  960. void pausa(void)
  961. {
  962. 	printf("\n Pulsar cualquier tecla para continuar...");
  963. 	getch();
  964. }
  965.  
  966. void iniciapoly(void)
  967. {
  968. 	polydat1=NULL;
  969. 	polydat2=NULL;
  970. 	polysum1=NULL;
  971. 	polysum2=NULL;
  972. 	polysuma=NULL;
  973. 	polymin=NULL;
  974. 	polysus=NULL;
  975. 	polyres=NULL;
  976. 	polyfac1=NULL;
  977. 	polyfac2=NULL;
  978. 	polyprod=NULL;
  979. 	polynum=NULL;
  980. 	polyden=NULL;
  981. 	polycos=NULL;
  982. 	polyres=NULL;
  983. 	polyresta=NULL;
  984. 	polyder=NULL;
  985. }
  986.  
  987. void insert_lista(struct apuntador **poly, float coefi, int expo)
  988. { //0
  989. 	struct apuntador *nuevo, *aux,*ant;
  990. 	int band=0;
  991. 	nuevo=(struct apuntador *) malloc (sizeof(nodo));
  992. 	if(nuevo == NULL)
  993. 	{//1
  994. 		printf("MEMORIA AGOTADA \n");
  995. 		return;
  996. 	}//-1
  997. 	nuevo->coef=coefi;
  998. 	nuevo->exp1=expo;
  999. 	nuevo->siguiente=NULL;
  1000. 	if(*poly==NULL)
  1001. 		*poly=nuevo;
  1002. 	else
  1003. 	{//-2
  1004. 		aux=*poly;
  1005. 		if(aux->exp1 < expo)
  1006. 		{ //3
  1007. 			nuevo->siguiente=*poly;
  1008. 			*poly=nuevo;
  1009. 		}//-3
  1010. 		else //EN OTRSOS CASOS
  1011. 		{//4
  1012. 		 while((aux)&&(band))
  1013. 		  {//5
  1014. 			 if(aux->exp1==expo)
  1015. 			  {//6 PARA TERMINO CON IGUAL EXPONENTE
  1016. 				aux->coef=aux->coef+coefi;
  1017. 				delete(nuevo); // O ES "if(aux->coef==0)"
  1018. 				band=1;
  1019. 			  }//-6
  1020. 			 else //PARA EL CASO: aux->exp1>expo
  1021. 			  {//7
  1022. 				if((aux->siguiente!= NULL)&&(expo>aux->siguiente->exp1))
  1023. 				 {//8
  1024. 				  nuevo->siguiente=aux->siguiente;
  1025. 				  aux->siguiente=nuevo;
  1026. 				  band=1;
  1027. 				 }//-8
  1028. 				else
  1029. 				 {//9
  1030. 				  if(aux->siguiente==NULL)
  1031. 					{//10
  1032. 					 aux->siguiente=nuevo;
  1033. 					 band=1;
  1034. 					}//-10
  1035. 				  else
  1036. 					ant=aux;
  1037. 					aux=aux->siguiente;
  1038. 				 }//-9
  1039. 			  }//-7
  1040. 		  }//-5
  1041. 		}//-4
  1042. 	}
  1043. }//-0
  1044.  
  1045. void imprime(struct apuntador *poly)
  1046. {
  1047. 	while(poly)
  1048. 	{
  1049. 		printf("\n\n Coeficiente : %f \n",poly->coef);
  1050. 		printf(" Exponente   : %i",poly->exp1);
  1051. 		poly=poly->siguiente;
  1052. 	}
  1053. }
  1054.  
  1055. void suma_poly(struct apuntador *poly1, struct apuntador *poly2,
  1056. 		struct apuntador **poly3)
  1057. {
  1058. 	float suma;
  1059. 	struct apuntador *primero;
  1060. 	primero = NULL;
  1061. 	suma=0;
  1062. 	while((poly1 != NULL) && (poly2 != NULL))
  1063. 	{
  1064. 		if (poly1->exp1 == poly2-> exp1)
  1065. 		{
  1066. 			suma=poly1->coef + poly2->coef;
  1067. 			if(suma !=0)
  1068. 			{
  1069. 				insert_lista(&primero,suma,poly1->exp1);
  1070. 			}
  1071. 			poly1=poly1->siguiente;
  1072. 			poly2=poly2->siguiente;
  1073. 		}
  1074. 		else
  1075. 			if(poly1->exp1 > poly2->exp1)
  1076. 			{
  1077. 				insert_lista(&primero,poly1->coef,poly1->exp1);
  1078. 				poly1=poly1->siguiente;
  1079. 			}
  1080. 			else
  1081. 			{
  1082. 				insert_lista(&primero,poly2->coef,poly2->exp1);
  1083. 				poly2=poly2->siguiente;
  1084. 			}
  1085. 			suma=0;
  1086. 	}
  1087. 	while(poly1 != NULL)
  1088. 	{
  1089. 		insert_lista(&primero,poly1->coef,poly1->exp1);
  1090. 		poly1=poly1->siguiente;
  1091. 	}
  1092. 	while(poly2 != NULL)
  1093. 	{
  1094. 		insert_lista(&primero,poly2->coef,poly2->exp1);
  1095. 		poly2=poly2->siguiente;
  1096. 	}
  1097. 	*poly3 = primero;
  1098. }
  1099.  
  1100. void multy_poly(struct apuntador *poly1, struct apuntador *poly2,
  1101. 		struct apuntador **poly3)
  1102. {
  1103. 	struct apuntador *primero;
  1104. 	float multy;
  1105. 	int sum;
  1106. 	struct apuntador *p, *q, *aux1, *aux2;
  1107.  
  1108. 	primero = NULL;
  1109. 	*poly3=NULL;
  1110. 	multy=1;
  1111. 	sum=0;
  1112. 	while(poly2 != NULL)
  1113. 		{
  1114. 			p=poly1;
  1115. 			while(p!=NULL)
  1116. 			{
  1117. 				multy=p->coef *poly2->coef;
  1118. 				sum=p->exp1 + poly2->exp1;
  1119. 				if(multy != 0)
  1120. 				{
  1121. 					insert_lista(&primero,multy,sum);
  1122. 					p=p->siguiente;
  1123. 				}
  1124. 				else
  1125. 				{
  1126. 					insert_lista(&primero,p->coef,p->exp1);
  1127. 					p=p->siguiente;
  1128. 					poly2=poly2->siguiente;
  1129. 				}
  1130. 				multy=1;
  1131. 			}
  1132. 			poly2=poly2->siguiente;
  1133. 		}
  1134. 		q = primero;
  1135. 		while(q)
  1136. 		{
  1137. 			if(q->exp1==q->siguiente->exp1)
  1138. 			{
  1139. 				q->coef=q->coef + q->siguiente->coef;
  1140. 				q->siguiente=q->siguiente->siguiente;
  1141. 			}
  1142. 			else
  1143. 				q=q->siguiente;
  1144. 		}
  1145. 		*poly3=primero;
  1146. }
  1147.  
  1148. void resta_poly(struct apuntador *poly1, struct apuntador *poly2,
  1149. 		struct apuntador **poly3)
  1150. {
  1151.     float resta;
  1152.     struct apuntador *primero;
  1153. 	 primero = NULL;
  1154. 	 resta= 0;
  1155.     while ((poly1 != NULL) && (poly2 != NULL))
  1156. 		 {
  1157. 	  if (poly1->exp1 == poly2->exp1)
  1158. 		 {
  1159. 			resta= poly1->coef - poly2->coef;
  1160. 			if (resta != 0) {
  1161. 		 insert_lista (&primero, resta, poly1->exp1); }
  1162. 			poly1= poly1->siguiente;
  1163. 			poly2= poly2->siguiente;
  1164. 		 }
  1165. 	  else
  1166. 		 if (poly1->exp1 > poly2->exp1)
  1167. 			{
  1168. 			 insert_lista (&primero, poly1->coef, poly1->exp1);
  1169. 			 poly1= poly1->siguiente;
  1170. 			}
  1171. 		 else
  1172. 			{
  1173. 			 insert_lista (&primero, poly2->coef, poly2->exp1);
  1174. 			 poly2= poly2->siguiente;
  1175. 			}
  1176. 	resta= 0;
  1177. 	 }
  1178.  
  1179. 	 while (poly1 != NULL)
  1180. 		{
  1181. 		insert_lista (&primero, poly1->coef, poly1->exp1);
  1182. 		poly1= poly1->siguiente;
  1183. 		}
  1184.  
  1185.     while (poly2 != NULL)
  1186. 		{
  1187. 		insert_lista (&primero, -poly2->coef, poly2->exp1);
  1188. 	   poly2= poly2->siguiente;
  1189. 		}
  1190.       *poly3 = primero;
  1191. }
  1192.  
  1193. void borrar_poly(struct apuntador **poly, int expo)
  1194. {
  1195. // aqui va el codigo correspondiente
  1196. }
  1197.  
  1198. void div_poly(struct apuntador *polynume, struct apuntador *polydeno,
  1199. 		struct apuntador **polycoci, struct apuntador **polyresi)
  1200. {
  1201.  
  1202. }
  1203.  
  1204. void der_poly(struct apuntador *poly1,struct apuntador **poly3)
  1205. {
  1206.  struct apuntador *primero=NULL;
  1207.  float co=0;
  1208.  int ex=0;
  1209.   while((poly1!=NULL)&&(poly1->exp1!=0))
  1210. 	{
  1211. 	 co=poly1->coef*poly1->exp1;
  1212. 	 ex=poly1->exp1-1;
  1213. 	 insert_lista(&primero,co,ex);
  1214. 	 poly1=poly1->siguiente;
  1215. 	}
  1216. }
  1217.  
  1218. float eval_poly(struct apuntador *poly1, float ev)
  1219.  {
  1220.   float res2;
  1221.   res2=0;
  1222.   while(poly1)
  1223. 	{
  1224. 	 res2=res2+poly1->coef*pow(ev,poly1->exp1);
  1225. 	 poly1=poly1->siguiente;
  1226. 	}
  1227. 	return (res2);
  1228.  }
  1229.  
  1230. void presentacion(void)
  1231. {
  1232. 	char c[1];
  1233. 	clrscr();
  1234. 	printf("\n\n                      PROGRAMA POLINOMIO \n\n");
  1235. 	printf("          REALIZA LA SUMA, RESTA, MULTIPLICACION Y DIVISION \n\n");
  1236.  
  1237. }
  1238.  
  1239. float factorial(int n)
  1240.   {
  1241.    int k;
  1242.    float f=1;
  1243.    for(k=1;k<=n;k++)
  1244.       f=f*k;
  1245.    return(f);
  1246.   }
  1247.  
4  Programación / Programación C/C++ / programa muestra resultado que no deberia en: 22 Septiembre 2012, 06:02 am
hola me gustaría recibir ayuda por parte de el equipo del foro tengo un progrma que calcula la ley de columb y al dividir entre cero se indetermina y se supone que me muestra un rotulo diciendo que no se puede calcular y el resultado debe dar cero, pero en este caso no lo hace me muestra un resultado , que no deberia de salir me pueden ayudar diciendo que esta mal, por que la profesora solo me confundio



Código
  1. #include<iostream.h>
  2. #include<conio.h>
  3. #include<math.h>
  4.  
  5. class coul
  6.  {
  7.   protected:
  8.    float q1,q2,r,d;
  9.   public:
  10.    void lee();
  11.    void calc();
  12.    void imp();
  13.  };
  14.  
  15. void coul::lee()
  16.  {
  17.   cout<<"\n Para el calculo de la ley de Coulumb de Q1, Q2 y R"<<endl;
  18.   cout<<"\n Da Q1 = ";
  19.   cin>>q1;
  20.   cout<<"\n Da Q2 = ";
  21.   cin>>q2;
  22.   cout<<"\n Da R = ";
  23.   cin>>r;
  24.  }
  25.  
  26. void coul::calc()
  27.  {
  28.   float k=9E9;
  29.   if(r!=0)
  30.    d=(k*(q1*q2))/pow(r,2);
  31.   else
  32.    cout<<"\n No se puede calcular con R = "<<r<<endl;
  33.  }
  34. void coul::imp()
  35.  {
  36.    cout<<"\n\n RESULTADO "<<endl;
  37.    cout<<"\n D = "<<d<<endl;
  38.  }
  39.  
  40. void main()
  41.  {
  42.   clrscr();
  43.   coul x;
  44.   x.lee();
  45.   x.calc();
  46.   x.imp();
  47.   getch();
  48.  }
Páginas: [1]
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines