Metodo de Secante

Este método, a diferencia del de bisección y regla falsa, casi nunca falla ya que solo requiere de 2 puntos al principio, y después el mismo método se va retroalimentando.

Lo que hace básicamente es ir tirando rectas secantes a la curva de la ecuación que se tiene originalmente, y va chequeando la intersección de esas rectas con el eje de las X para ver si es la raíz que se busca.

Procedimiento:

Primero hay que definir algunos conceptos como:

• Xn es el valor actual de X
• Xn-1 es el valor anterior de X
• Xn+1 es el valor siguiente de X

Para simplificar la formula que se usa en este método se dirá que:

• A=Xn-1
• B=Xn+1
• C=Xn

Como su nombre lo dice, este método va trazando rectas secantes a la curva original, y como después del primer paso no depende de otras cantidades sino que solito va usando las que ya se obtuvieron, casi nunca falla porque se va acomodando hasta que encuentra la raíz.

• Lo primero que se hace, igual que con otros métodos es dar 2 puntos cualesquiera que sean sobre el eje de las X que se llaman A y C.
• Después se sustituyen esos puntos en la ecuación original para obtener f(A) y f(C).
• Una vez que se tienen todos esos datos se obtiene el punto B con la formula B=((Af(C))-(C(f(A)))/(f(C)-f(A)).

A diferencia del resto de los métodos, aquí no hay que acomodar en columnas cada uno de los datos, sino que se utiliza la simplificación de conceptos y como se simplifica la formula para seguir con el método. Aqui solo se usan 2 columnas, una de Xn y otra de f(Xn).Vista previa

Algoritmo:

Entrada: Aproximación inicial de x0 y x1
Tolerancia T
Máximo número de iteraciones N
Salida: Un valor aproximado de la raíz o un mensaje de error

Paso1: Asigne i = 2
q0 = f(x0)
q1 = f(x1)

Paso2: Mientras i <= N0 haga Pasos 3-6

Paso3: Encuentre x = x1 - q1(x1 -x0) / (q1-q0)

Paso4: Si |x - x1 | < T

Entonces Salida (x);

Parar.

Paso5: Asigne i = i+1

Paso6: Asigne x0 = x1
x1 = x
q0 = q1
q1 = f(x)

Paso7: Salida ("Método falló luego de N0 iteraciones").

Parar

Metodo de la Regla Falsa

En cálculo numérico, el método de regula falsi (regla falsa) o falsa posición esun método iterativo de resolución numérica de ecuaciones no lineales. El método combina el método de bisección y el método de la secante.

Este método sirve para encontrar la raíz o solución real de una ecuación. Al decir que encuentra su resultado hay que tomar en cuenta que no todas las ecuaciones tienen un solo resultado, y que no todas tienen resultado, por lo que hay que tener una idea dela forma de la curva de la ecuación antes de aplicar el método para que sea efectivo.

PROCEDIMIENTO

Como mencionamos anteriormente, sería bueno considerar si la raíz de una ecuación está localizada más cerca de alguno de los extremos del intervalo.

• Consiste en considerar un intervalo (xi, xs) en el que se garantice que la función tiene raíz. 
• Se traza una recta que une los puntos (xi, f(xi)), (xs, f(xs)) 
• Se obtiene el punto de intersección de esta recta con el eje de las abscisas: (xr, 0); se toma xr como aproximación de la raíz buscada. 
• Se identifica luego en cuál de los dos intervalos está la raíz. 
• El proceso se repite n veces, hasta que el punto de intersección xr coincide prácticamente con el valor exacto de la raíz. 

Método de la regla falsa - Aplicación en Matlab:

disp(' METODO DE LA REGLA FALSA ');
disp(' ---------------------- ');

%f=input('INGRESE FUNCION: ','s');
f='exp(-x)-log(x)';
%xai=input('INGRESE LIMITE INFERIOR DEL INTERVALO: ');
xai=1;
%xbi=input('INGRESE LIMITE SUPERIOR DEL INTERVALO: ');
xbi=2;


%tol=input('INGRESE PORCENTAJE DE ERROR: ');
tol=1;


f=inline(f);
i=1;
ea(1)=100;

if f(xai)*f(xbi) <>= tol,
if f(xa(i))*f(xr(i))<> 0
xa(i+1)=xr(i);
xb(i+1)=xb(i);

end


%xr(i+1)=(xa(i+1)+xb(i+1))/2;
xr(i+1)=xa(i+1)-(f(xa(i+1))*(xb(i+1)-xa(i+1)))/(f(xb(i+1))-f(xa(i+1)));
ea(i+1)=abs((xr(i+1)-xr(i))/(xr(i+1))*100);
fprintf('%2d \t %11.7f \t %11.7f \t %11.7f \t %7.3f \n',...
i+1,xa(i+1),xr(i+1),xb(i+1),ea(i+1));
i=i+1;
end

else

fprintf('No existe una raíz en ese intervalo');

end

Raices de ecuaciones

Teorema fundamental del álgebra:

Todo polinomio de grado n, con coeficientes complejos, tiene exactamente n raíces, no forzosamente distintas, es decir contadas con su orden de multiplicidad.

Por ejemplo, el polinomio real (y por lo tanto también complejo):x3 − 2x2 − 4x + 8 = (x − 2)2(x + 2)

tiene 2 como raíz doble, y -2 como raíz simple, lo que da en total tres raíces.

En otras palabras, todo polinomio:

se puede factorizar completamente, así:,

con los zi complejos, y .

Los números complejos fueron inventados justamente para encontrar raíces de polinomios reales: i es por construcción una raíz de x2 + 1. Lo extraordinario del teorema es que no hace falta inventar un número para cada polinomio real que se quiera factorizar, porque con todas las combinaciones lineales entre i y 1 (es decir con los a + bi) se puede factorizar todos los polinomios reales, y también complejos. Esa propiedad significa que el cuerpo de los complejos es algebraicamente cerrado: no se puede salir de él buscando raíces de polinomios, que es la operación algebraica por excelencia.

Se tardaron dos siglos para completar la prueba de este teorema, del diecisiete al diecinueve. Figuras destacadas en esta labor fueron d'Alembert y Gauss, este último encontró distintas pruebas. En algunos países el teorema lleva el nombre de teorema de d'Alembert – Gauss (o en el orden inverso, o con un solo apellido). Hoy en día la prueba más elegante está basada en la inducción, y su primer paso es demostrar que un polinomio no constante (es decir de grado superior o igual a uno) debe tener una raíz, gracias al teorema de Liouvilleaplicado a la función inversa del polinomio, que es una función holomórfica, es decir derivable en el sentido complejo. Luego se factoriza la función P(x) por x − r, donde r es la raíz que acabamos de encontrar, y se repite la operación con el cociente:

METODOS PARA ENCONTRAR RAICES

1. Regla falsa 
2. Biseccion
3. Grafico
4. Punto fijo
5. Newton Raphson
6. Secante

Graficador XY

En el modo gráfico existe una enorme cantidad de funciones que realizan desde la tarea mas sencilla como es pintar un píxel, hasta la tarea mas compleja como pudiera ser dibujar un carácter por medio de trazos.

Para trabajar el modo gráfico es necesario incluir la librería graphics.h como hacer uso de la BGI (Borlan Graphics Interphase). Para usar cualquier función es necesario colocar el adaptador de video en modo grafico y esto se logra a través de la función initgraph(); y al terminares necesario regresar al modo original a través de la función closegraph();

Para iniciar un programa en ambiente gráfico es recomendable correr una subrutina de inicialización de gráficos y detección de errores.Algunos ejemplos de las funciones que se pueden encontrar en la librería de gráphics.h son:

Line(); circle(); arc(); elipse();rectangle(); ottextxy(); putpixel();Para saber mas de las funciones de la librería de gráficos lo pueden buscar en el índice de turbo C.

ESTRUCTURA DEL PROGRAMA

#include <graphics.h>

#include <stdlib.h>

#include <stdio.h>

#include <conio.h>

int main(void)

{

VARIABLES PARA INICIALIZAR MODO GRAFICO

int gdriver = DETECT, gmode, errorcode;

INICIALIZAR MODO GRAFICO

initgraph(&gdriver, &gmode, "");

DETECTA SI HAY ALGUN ERROR PARA USAR MODO GRAFICO

errorcode = graphresult();

if (errorcode != grOk)

{

printf("Graphics error: %s\n", grapherrormsg(errorcode));

printf("Press any key to halt:");

getch();

exit(1);

}

line(0, 0, 50,50 ); DIBUJA UNA LINEA

getch();

closegraph(); CERRAR MODO GRAFICO

return 0;

}

FUNCIONES PARA DIBUJAR

cleardevice(void); LIMPIA LA PANTALLA

setcolor(int color); COLOR DE LINEA

setbkcolor(int color); COLOR DE FONDO (PANTALLA)

TAMAÑO O RESOLUCION DE LA PANTALLA 640X480 PIXELS

line(int x1, int y1, int x2, int y2); DIBUJA UNA LINEA

rectangle(int left, int top, int right, int bottom); DIBUJA UN RECTANGULO

rectangle(izqierda,arriba,derecha,abajo);

putpixel(int x, int y, int color); PINTA UN PIXEL

outtextxy(int x, int y, char far *textstring); DIBUJA TEXTO

outtextxy(100,100,”Programa 1”);

settextstyle(int font, int direction, int charsize); TIPO DE LETRA A USAR

settextstyle(tipo letra, direccion, tamaño letra);

TIPOS DE LETRA (FONT)

0 DEFAULT_FONT

1 TRIPLEX_FONT

2 SMALL_FONT

3 SANS_SERIF_FONT

4 GOTHIC_FONT

DIRECTION

0 HORIZ_DIR

1 VERT_DIR

settextjustify(int horiz, int vert); JUSTIFICAR TEXTO

HORIZ

0 LEFT_TEXT IZQUIERDA

1 CENTER_TEXT CENTRADO

2 RIGHT_TEXT DERECHA

VERT

0 BOTTOM_TEXT ABAJO

1 CENTER_TEXT CENTRADO

2 TOP_TEXT ARRIBA

RELLENADO DE FIGURAS

floodfill(int x, int y, int border); RELLENAR FIGURA

setfillstyle(int pattern, int color); TIPO DE RELLENO Y COLOR A USAR

Descarga aqui un graficador !

http://www.taringa.net/posts/downloads/1344988/GraphCalc-4_0_1-_Graficador-de-funciones-3D_-2D_.html

Números de punto flotante en 32 y 64 bits.

El estándar de la IEEE para aritmética en coma flotante (IEEE 754) es el estándar más extendido para las computaciones en coma flotante, y es seguido por muchas de las mejoras de CPU y FPU. El estándar define formatos para la representación de números en coma flotante (incluyendo el cero) y valores desnormalizados, así como valores especiales como infinito y NaN, con un conjunto de operaciones en coma flotante que trabaja sobre estos valores. También especifica cuatro modos de redondeo y cinco excepciones (incluyendo cuándo ocurren dichas excepciones y qué sucede en esos momentos).

IEEE 754 especifica cuatro formatos para la representación de valores en coma flotante: precisión simple (32 bits), precisión doble (64 bits), precisión simple extendida (≥ 43 bits, no usada normalmente) y precisión doble extendida (≥ 79 bits, usualmente implementada con 80 bits). Sólo los valores de 32 bits son requeridos por el estándar, los otros son opcionales. Muchos lenguajes especifican qué formatos y aritmética de la IEEE implementan, a pesar de que a veces son opcionales.

Precisión simple 32-bits

Un número en coma flotante de precisión simple se almacena en una palabra de 32 bits. 1 8 23 <-- tamaño en bits

+-+--------+-----------------------+

|S| Exp | Significante |

+-+--------+-----------------------+

31 30 23 22 0 <-- índice del bit (0 a la derecha)

desplazado +127

donde S es el bit de signo y Exp es el campo exponente. (Para el signo: 0=Positivo ; 1= Negativo).

El exponente es desplazado en el un número en precisión simple, un exponente en el rango −126 a +127 es desplazado mediante la suma de 127 para obtener un valor en el rango 1 a 254 (0 y 255 tienen valores especiales descritos más adelante). Cuando se interpreta el valor en coma flotante, el número es desplazado de nuevo para obtener el exponente real.

El conjunto de valores posibles pueden ser divididos en los siguientes:

• ceros
• números normalizados
• números desnormalizados
• infinitos
• NaN (¬E, no es un número, como por ejemplo, la raíz cuadrada de un número negativo)

Las clases se distinguen principalmente por el valor del campo Exp, siendo modificada ésta por el campo fracción. Considera Exp y Fracción como campos de números binarios sin signo (Exp se encuentra en el rango 0–255): 

Clase	Exp	Fracción
Ceros	0	0
Números desnormalizados	0	distinto de 0
Números normalizados	1-254	cualquiera
Infinitos	255	0
NaN (Not a Number)	255	distinto de 0

Para números normalizados, los más comunes, Exp es el exponente desplazado y Fracción es la parte fraccional del significante (o significando). El número tiene valor v:

v = s × 2e × m

Donde

s = +1 (números positivos) cuando S es 0

s = −1 (números negativos) cuando S es 1

e = Exp − 127 (en otras palabras, al exponente se le suma 127 y se almacena, a esto también se le llama "biased with 127" en inglés)


m = 1,Fracción en binario (esto es, el significando es el número binario 1 seguido por la coma decimal seguido por los bits de Fracción). Por lo tanto, 1 ≤ m < 2.