Interpolacion por el Método de Newton

#include<stdio.h>
#include<conio.h>
#include<math.h>
#include<process.h>
#include<string.h>

void main(){
 int n;
 int i,j;
 float ax[10];
 float ay[10];
 float y=0;
 float x;
 float h;
 float p;
 float diff[20][20];
 float y1,y2,y3,y4;

 printf("\n Numero de Terminos: ");
 scanf("%d",&n);
 printf("\n\n Valor de X: ");
 for(i=0;i<n;i++){
  printf("\n\n Valor de x%d: ",i+1);
  scanf("%f",ax[i]);
  
 }
 
  printf("\n\n Valor de Y: ");
 for(j=0;j<n;j++){
  printf("\n\n Valor de y%d: ",i+1);
  scanf("%f",ay[i]);
  
 }
printf("\n Valor para x: ");
printf("\n Valor para y: ");
scanf("%f",&x);
 h = ax[1]-ax[0];
  for(i=0;i<n-1;i++){
   diff[i][1]=ay[i+1]-ay[i];
  }
   for(j=2;j<=4;j++){
    for(i=0;i<n-j;i++){
     diff[i][j]=diff[i+1][j-1]-diff[i][j-1];
    }
   }
   i=0;
    do{
     i++;
    }while(ax[i]<x);
    i--;
    p=(x-ax[i])/h;
    y1= p*diff[i-1][1];
    y2=p*(p+1)*diff[i-1][2]/2;
    y3=(p+1)*p*(p-1)*diff[i-2][3]/6;
    y4 = (p+2)*(p+1)*p*(p-1)*diff[i-3][4]/24;
    y =ay[i]+y1+y2+y3+y4;
      
      printf(" x= %6.4f, y= 6.4%f ",x,y);
      printf("\n\n\n Enter para Salir");
      getch();
}

Regresamos!!!!!

Regresamos con nuevos temas y metodologías para  postear en este blog.

En primer lugar  dedicare el mes de octubre al Tema de interpolación,  sus diferentes métodos y algoritmos empleados, compartiendo los códigos como siempre y algunas aplicaciones. Tratando de enfatizar en las aplicaciones.

Por lo que  si alguien desea que se toque algún tema en específico, puede postearlo en forma de comentario.

¿Qué es la interpolación?

La obtención de nuevos puntos partiendo del conocimiento de un conjunto discreto de puntos.

En ingeniería y algunas ciencias es frecuente disponer de un cierto número de puntos obtenidos por muestreo o a partir de un experimento y pretender construir una función que los ajuste.

Otro problema estrechamente ligado con el de la interpolación es la aproximación de una función complicada por una más simple. Si tenemos una función cuyo cálculo resulta costoso, podemos partir de un cierto número de sus valores e interpolar dichos datos construyendo una función más simple. En general, por supuesto, no obtendremos los mismos valores evaluando la función obtenida que si evaluamos la función original, si bien dependiendo de las características del problema y del método de interpolación usado la ganancia en eficiencia puede compensar el error cometido.

Fuente: 

Newton-Raphson en C

#include<stdio.h>
#include<string.h>
#include<conio.h>
#include<math.h>
#include<process.h>

#define f(x) 3*x -cos(x) -1
#define df(x) 3 -sin(x)

void nwrap();

void main(){
 printf("\n Solucion por el Método de Newton Raphson \n");
 printf("\n F(x): ");
 printf("\n\t\t\t 3*x -cos(x) -1 = 0 \n\t");
 nwrap();
 getch();
}

void nwrap(){
 float x1,x0;
 float f1,f0;
 float df0;
 int i=0, itr=0;
 float TOL;
 float error;
   for(x1=0;;x1 +=0.01){
    f1=f(x1);
    if (f1>0){
     break;
    }
   }
x0 = x1-0.01;
f0 = f(x0);
printf("Numero de Iteraciones: ");
scanf("%d",&itr);
printf("Tolerancia Maxima: ");
scanf("%f",&TOL);
     if(fabs(f0)>f1){
      printf("\n\t\t La raiz es: %0.4f\n",x1);
     }
     if(f1 > fabs(f(x0))){
      printf("\n\t\t La raiz es: %0.4f\n",x1);
 }
x0 = (x0+x1)/2;
for(;i<=itr;i++){
 f0=f(x0);
 df0=df(x0);
 x1 = x0 - (f0/df0);
 printf("\n\t\t iteracion %d  aproximacion: %f",i,x1);
 error = fabs(x1-x0);
   if(error < TOL){
    break;
   }
 x0 = x1;
}
   if(error > TOL){
    printf("\n\n\t Iteraciones No suficientes" );    
   }
printf("\n\n\n\t\t\t--------------------------");
printf("\n\n\t\t Raiz: %0.4f ",x1);
printf("\n\n\n\t\t\t--------------------------");
}

Método de Falsa Posicion en C

# include <stdio.h>
# include <math.h>
# include<conio.h>
# include<string.h>
# include<process.h>
#define TOL 0.000005
#define f(x) 3*x+sin(x)-exp(x)

void falsaposicion();

void main() {
	printf("\n Solucion por el metodo de Falsa posicion \n");
	printf("\n La Ecuacion a resolver es: ");
	printf("\n\t\t\t 3*x+sin(x)-exp(x)= 0 \n\n");
falsaposicion();	
}

void falsaposicion(){
	float f0,f1,f2;
	float x0,x1,x2;
	int itr;
	int i;
	printf("Numero Maximo de Iteracciones: ");
	scanf("%d",&itr);
	for(x1=0.0;;){
		f1=f(x1);
		if (f1>0){
			break;
		}
		 else {
		 	x1 = x1+0.1;
		 }
	}
			
	x0= x1-0.1;
	f0 = f(x0);
	printf("\n\t\t----------------------------------------");
	printf("\n\t\t Iteraccion\t x\t\t F(X) \n");
	printf("\n\t\t----------------------------------------");
	  for(i=0;i<itr;i++){
	  	x2 = x0-((x1-x0)/(f1-f0))*f0;
	  	f2=f(x2);
	  	 if(f0*f2>0){
	  	 	x1=x2;
	  	 	f1=f2;
	  	 }
	  	   else {
	  	    	x0=x2;
	  	    	f0=f2;
	  	   }
	  	     if (fabs(f(2))>TOL){
	  	     	printf("\n\t\t%d\t%f\t%f\n",i+1,x2,f2);
	  	     }
	  }
	  printf("\t\t--------------------------------");
	  printf("\n\t\t\t Raiz= %f\n",x2);
	  printf("\t\t------------------------------");
	  getch();
			}

Método de Bisección en C, Usando funciones

# include<stdio.h>
# include<conio.h>
# include<math.h>
# include<process.h>
# include<string.h>
# define TOL 0.000001
# define F(x) (x)*log10(x) - 1.2

void Bisect();
int i=1, n;
float raiz = 1;

void main(){
 printf("\n Solucion por el Metodo de Biseccion \n");
 printf ("\n La ecuacion es: ");
 printf("\n\t\t\t (x)*log10x) -1.2 = 0 \n\n");
 printf("Numero Maximo de Iteracciones: ");
 scanf ("%d",&n);
 Bisect();
}
void Bisect(){
 float x1,x2,x0;
 float f0,f1,f2;
 int j=0;
  for (x2=1;;x2++){
   f2 = F(x2);
   if(f2 >0){
    break;
   }
   
  }
  for (x1=x2-1;;x2--){
   f1 = F(x1);
   if(f1<0){
    break;
   }
  }
printf ("\t\t------------------------------------\t\t");
printf ("\n\t\t Iteracion                 Raiz \n");
printf("\t\t-------------------------------------\t\t");
 for (;i<=n;i++){
  x0 = (x1+x2)/2.0;
  f0 = F(x0);
    if (f0==0){
     raiz = x0;
    }
  if(f0*f1<0){
   x2=x0;
  }
     else{
      x1 = x0;
      f1= f0;
     }
  printf("\n\t\t Iteracion %d ", i);
  printf("\t  :\t %f", x0);
  if(fabs((x1-x2)/x1) < TOL ){
  printf("\n\t\t ------------------------------------");
    printf("\n\t\t Raiz = %f",x0);
 printf("\n\t\t Iteracion = %d\n",i);
 printf("\t\t-------------------------------------");
 getch(); 
   exit(0);
   }
  }
printf("\n\t\t---------------------------------------");
printf("\n\t\t\t Raiz = %7.5f",x0);
printf("\n\t\t\t Iteracion = %d\n", i-1);
printf("\t\t-----------------------------------------");
 
getch();
}

Ejecutando:

Balanceo de Ecuaciones Químicas Online

http:// www.webqc.org/balance.php

http://balance-equation.appspot.com/

Avogadro es un programa para dibujar estructuras moleculares realizando enlaces químicos, se pueden visualizar en 3D rotando la estructura, cambiando la perspectiva visual, y haciéndola girar en cualquier sentido y dirección sólo con los movimientos del ratón. Las vistas de las estructuras moleculares son espectaculares.

=DESCARGAR=

Python For Bioinformatics (Archivos del libro)

Estos archivos son los ejemplos que trae el libro  python for bioinformatics.

D..E..S..C..A..R..G..A..R

'Kalzium' un gran Software de GNU para estudiantes de Quimica

Kalzium proporciona todo tipo de información sobre la tabla periódica de los elementos. Puede obtener abundante información sobre los elementos, además de utilizar distintos modos de visualización para mostrarlos. Es libre y está sujeto a los términos de la licencia pública GNU.

Puede visualizar la tabla periódica de los elementos por grupos, bloques y familias. Puede visualizar gráficos de datos de las propiedades de un grupo de elementos, como su punto de ebullición o su masa atómica. Puede viajar atrás en el tiempo para ver qué elementos eran conocidos en una fecha determinada. También puede calcular masas moleculares.

GUIA DESCARGA WINDOWS

Operación con matrices usando Sympy-Python

isra@linuxmint ~ $ python
Python 2.7.4 (default, Sep 26 2013, 03:20:56) 
[GCC 4.7.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> from sympy import Matrix
>>> Matrix([[1,2,3],[4,6,7]])
[1, 2, 3]
[4, 6, 7]
>>> A=Matrix([[1,2,3],[4,6,7]])
>>> b=3
>>> c = b*A
>>> c
[ 3,  6,  9]
[12, 18, 21]
>>> 
>>> x=Symbol('x')
>>> y=Symbol('y')
>>> H = Matrix([[x+y,4],[3,x-y]])
>>> H
[x + y,     4]
[    3, x - y]
>>> h = H*H
>>> h
[(x + y)**2 + 12,             8*x]
[            6*x, (x - y)**2 + 12]
>>> #matris identidad
... 
>>> eye(4)
[1, 0, 0, 0]
[0, 1, 0, 0]
[0, 0, 1, 0]
[0, 0, 0, 1]
>>> #matris ceros
... 
>>> zeros(4)
[0, 0, 0, 0]
[0, 0, 0, 0]
[0, 0, 0, 0]
[0, 0, 0, 0]
>>> #matris unos
... 
>>> ones(5,6)
[1, 1, 1, 1, 1, 1]
[1, 1, 1, 1, 1, 1]
[1, 1, 1, 1, 1, 1]
[1, 1, 1, 1, 1, 1]
[1, 1, 1, 1, 1, 1]
>>> v1 = Matrix([1,2,3])
>>> v2 = Matrix([5,7,8])
>>> v3 = v1.cross(v2)
>>> v3
[-5, 7, -3]
>>> #producto punto
... 
>>> v4 = v1.dot(v2)
>>> v4
43