• No se han encontrado resultados

Métodos Numéricos con JAVA Introducción

N/A
N/A
Info
Descargar
Protected

Academic year: 2021

Share "Métodos Numéricos con JAVA Introducción"

Copied!
155
0
0

Cargando.... (Ver texto completo ahora)

Descargar ahora ( 155 página )

Texto completo

(1)

EL Java es el lenguaje para el Internet, y entre sus características esta que es un lenguaje de

programación orientada a objetos; nuestro propósito es desarrollar en este lenguaje métodos

numéricos que permiten las aplicaciones de ingeniería de tal forma que se puedan hacer

programas que se bajen por Internet en cualquier parte del mundo.

En esta primera entrega analizaremos la estructura de objetos inicial para poder operar con

funciones y polinomios, como primeros métodos veremos como integrar y derivar polinomios y

por medio de esto se hallará una de sus raíces. Para las funciones no lineales desarrollaremos

el método de la bisección para encontrar una raíz.

Clases: Se definio entonces una clase padre de nombre MetodoNumerico, pensemos cual

podria ser datos generales para cualquier método numérico, esto es tolerancia y el número

máximo de iteraciones, deberia ser estaticas pues no se podria considerar que la toleracia sea

un dato para cada instancia de la clase, sino más bien se pertenece a la clase, es por esta

razon que se la definio static.

(2)

Un constructor que me permita modificar los valores de tolerancia y el número máximo de

iteraciones, el cual por herencia puede ser usado en las subclases de ella.

     Polinomios

Un polinomio se halla definido como:

public class Polinomio extends MetodoNumerico {

/*————————————————–

grado y coeficiente son atributos de cada uno de los Polinomios

especificos a crear (Instancias),gradoMax es el maximo valor de grado

que puede poseer un Polinomio

(3)

super();

// super.tolerancia=5E-3;

/* Máximo número de iteraciones */

//super.maxIteraciones=30;

}

/*Constructor de Polinomio con dos argumentos

el grado del polinomio y los coeficientes.

*/ public Polinomio(int grado,double[] coeficientes) {

this();

this.grado=grado;

this.coeficientes=coeficientes;

}

/* Constructor de Polinomio con dos argumentos

el grado del polinomio y los coeficientes.

*/

public Polinomio(int grado,double[]

coeficientes,double tol, int maxIter) {

// this();

(4)

sis, creamos una variable static, de

nombre gradoMax, que es el

máximo grado de los polinomios,

existen además dos atributos, uno

de ellos de nombre grado que será

double y que al crear las instancias

cada polinomio que se cree tendrá

su propio grado, por tanto este será

un atributo que pertenecerá a cada

instancia de Polinomio que se cree,

bajo el mismo análisis podemos

(5)

double[Polinomio.gradoM

ax];

En este vector se almacenara la

solución del problema.

(6)

definido será una

instancia de la clase

Polinomio, y este

tendrá su vector de

coeficientes en su

correspondiente

atributo coeficientes

(7)

11, 6, 1};

Polinomio

p1=new

(8)

ejemplo grado

3 y los

coeficientes

que se

(9)

entonces

creado el

(10)

    

Derivación e

Integración

(11)

propiedad de

los polinomios

mediante la

cual se puede

encontrar su

(12)

mediante la

expresión

(13)

Y cuando

se integra

un

polinomio

(14)

os el

siguiente

(15)
(16)

es una

constante

de

integración

.

(17)

/* Este

metodo

me

permite

calcular

(18)

los valores

de los

coeficiente

s de la

(19)

del

polinomio

*/

(20)

public

double[]

coeficiente

sDerivada

()

(21)

{ double

derivadas[

]=new

double[Pol

inomio.gra

(22)

doMax];

for (int i=1;

i<=this.gra

do; i++)

(23)

derivadas[

i-1]=(i)*this

.coeficient

es[i];

(24)

return

derivadas;

}

(25)

/* Este

método

nos

permite

(26)

polinomio

correspon

diente al

valor de la

derivada

(27)

del

polinomio

dato

(28)

public

Polinomio

derivada()

{ double

(29)

]=new

double[Pol

inomio.gra

doMax];

(30)

i<=this.gra

do; i++)

{

derivadas[

i-1]=(i)*this

(31)

.coeficient

es[i];

}

return new

Polinomio(

(32)

this.grado,

derivadas)

;

(33)

/* Este

método

nos

permite

calcular

(34)

los valores

de los

coeficiente

s de la

(35)

polinomio

con

costante

de

(36)

igual a 0

(37)

public

double[]

coeficiente

sIntegral()

{ double

(38)

integral[]=

new

double[Pol

inomio.gra

doMax];

(39)

for (int i=1;

i<=this.gra

do; i++)

{

(40)

1]=this.co

eficientes[i

]/(i+1);

}

(41)

=0;

return

integral;

}

(42)

/* Este

método

permite

calcular

(43)

de los

coeficiente

s de la

integtral

del

(44)

polinomio

con

costante

de

(45)

igual dado

por la

llamada al

metodo

(46)

*/

public

double[]

coeficiente

sIntegral(d

(47)

ouble psi)

{ double

integral[]=

new

(48)

inomio.gra

doMax];

for (int i=1;

i<=this.gra

do; i++)

(49)

{

integral[i+

1]=this.co

eficientes[i

]/(i+1);

(50)

}

integral[0]

=psi;

return

(51)

}

(52)

metodo

permite

obtener el

polinomio

correspon

(53)

diente al

valor de la

integral del

polinomio

(54)

costante

de

integracion

igual a 0

(55)

*/

public

Polinomio

integralPol

inonio()

(56)

{ double

integral[]=

new

double[Pol

inomio.gra

(57)

doMax];

for (int i=1;

i<=this.gra

do; i++)

(58)

integral[i+

1]=this.co

eficientes[i

]/(i+1);

(59)

integral[0]

=0;

return new

Polinomio(

this.grado,

(60)

integral);

}

(61)

/* Este

metodo

permite

obtener el

polinomio

(62)

correspon

diente al

valor de la

integral del

polinomio

(63)

dato con

costante

de

integracion

igual dado

(64)

por la

llamada al

metodo

(65)

*/

public

Polinomio

integralPol

inonio(dou

(66)

ble psi)

{ double

integral[]=

new

(67)

inomio.gra

doMax];

for (int i=1;

i<=this.gra

do; i++)

(68)

{

integral[i+

1]=this.co

eficientes[i

]/(i+1);

(69)

}

integral[0]

=psi;

return new

Polinomio(

(70)

this.grado,

integral);

}

}

(71)

/*

evaluaPoli

nomio es

el metodo

(72)

el

polinomio

para un

valor de x

dado,

(73)

notese

que se

debera

aplicar

este

(74)

metodo en

la

instancia

debido a

(75)

método

miembro

de la clase

Polinomio

(76)

*/

public

double

evaluaPoli

nomio(dou

(77)

ble x){

double b;

int n =

this.grado;

b =

(78)

this.coefici

entes[this.

grado];

for (int i=

–n; i>=0;

(79)

i–)

{

b = b * x +

this.coefici

entes[i];

(80)

}

return b;

}

(81)

/*

evaluaPoli

nomioS

Este

(82)

static por

tanto se

pertenece

a la clase,

y la

(83)

instancia u

objeto

debe

ingresar

como

(84)

argumento

del

(85)

*/

public

static

double

(86)

nomioS(P

olinomio

p1,double

x){

(87)

int n =

p1.grado;

b =

p1.coeficie

ntes[p1.gr

(88)

ado];

for (int i=

–n; i>=0;

i–)

(89)

b = b * x +

p1.coeficie

ntes[i];

}

(90)

}

public

double

evaluaDeri

vadaPolin

(91)

omio

(double x)

{

double b;

int n =

(92)

this.grado;

b =

this.grado

*

(93)

entes[this.

grado];

for (int i=

–n; i>=1;

i–)

(94)

{

b = b * x +

i *

this.coefici

entes[i];

(95)

}

return b;

}

(96)

Este es un

método

analitica

de

(97)

cual tiene

su

ejemplifica

cion en el

(98)

nombre

coeficiente

sDerivada

y

(99)

sIntegral,

que se

puede

observar

en el

(100)

diagrama

de clases

arriba

(101)

  

    

Método

de

(102)

newton

para la

obtenció

n de una

raíz

(103)
(104)

Sea un

polinomio

P(X) y

(105)

de una raíz

nosotros

podemos usar

la recta

(106)

valor más

cercano por

medio de:

(107)

procedimiento

hasta que entre

dos valores

consecutivos

se hayan

(108)

K de dígitos

iguales usando

para ello 

(109)

raíz será el

valor de X

n

(110)

método

newtonPolinomio,

que emplea el

método arriba

descrito.

(111)

newtonPolinomio

(double xEntrada)

{ int i;

double x, xAnt,fx,

fDx;

i = 0;

x = xEntrada;

(112)

while (i

{ i++;

fDx =

this.evaluaDerivad

aPolinomio(x);

xAnt = x;

x = x - fx / fDx;

(113)

mio(x);

if (Math.abs((x

-xAnt) / -xAnt) <

Polinomio.toleranc

ia)

i =

Polinomio.maxIter

(114)

return x;

}

public String

newtonPolinomio

String (double

xEntrada)

{ int i;

double x, xAnt,fx,

(115)

xString=”Trabajan

do”;

i = 0;

x = xEntrada;

fx=this.evaluaPoli

nomio(x);

while (xString ==

(116)

{

if (Math.abs(x) <

Polinomio.casiCer

o)

xString = “Fallo x

= 0″;

else

(117)

fDx =

this.evaluaDeriva

daPolinomio(x);

if(Math.abs(fDx) <

Polinomio.casiCer

o)

(118)

else

{

xAnt = x;

x = x - fx / fDx;

fx =

this.evaluaPolino

mio(x);

(119)

Polinomio.toleran

cia)

xString = “”+x;

else

{if(i ==

Polinomio.maxIter

(120)

máximas

iteraciones”;

}

}

}

}

return xString;

(121)

     Funciones

No Lineales

(122)

encontramos

desarrollandola

aun, pero

hemos decidido

adelantarles

nuestro trabajo

(123)

Método de la

bisección.

El método de

la bisección se

halla basado

(124)

que el valor de

la función

cambia de

signo en los

(125)

Necesitare

mos un

(126)

[a,b] donde

dicha

función

cambie de

signo (

(127)

f(a)*f(b)<0)

pues allí

casi con

seguridades

encontrara

(128)

una raíz. Se

encuentra a

continuació

n el centro

(129)

( X = ( a + b

) / 2 ) y se

verifica que

f ( a ) * f ( x

) < 0 si esto

(130)

ocurre se le

asigna b = x

caso

contrario a

= x

(131)

reduciendo

el ancho del

intervalo a

la mitad,

este

(132)

proceso

continua

reduciéndol

o hasta que

este sea

(133)

menor que

un cierto

valor de

tolerancia.

Cuando se

(134)

alcanza

dicha

condición la

raíz se

(135)

en el centro

del intervalo

( raíz ( a + b

) / 2 ).

(136)

class

Funcion

extends

MetodoNu

merico {

(137)

/*

Constructo

r que

permite

(138)

super

constructor

MetodoNu

merico

*/

(139)

public

Funcion()

{

}

(140)

Funcion(do

uble tol, int

maxIter)

{

(141)

axIter);

}

(142)

/*

el metodo

biseccion

que

(143)

ceros de la

funcion a

traves del

metodo de

la

(144)

biseccion

*/

(145)

public

double

biseccion

(double xo,

double xf)

(146)

{

double

x,fx,xant=0

;

(147)

double

fo=f(xo);

do {

x = (xo +

xf)/2;

(148)

fx = f(x);

i++;

if

(fo*fx<=0)

{

(149)

xf = x;

}

else {

xo = x;

fo = fx;

(150)

}

if

(Math.abs((

x-xant)/x)

(151)

i=MetodoN

umerico.m

axIteracion

es;

(152)

else {

xant = x;

}

}

(153)

(i>=Metod

oNumerico

.maxIteraci

ones);

(154)

+ xf)/2;

}

(155)

Referencias

Descargar ahora ( PDF - 155 página - 551.96 KB )

Documento similar

Nombre que se debe proteger Campo de la Guardia 2

- Fase Visual: Color rojo cereza. Puede presentar un pequeño precipitado de sales tartáricas o de polifenoles polimerizados. - Fase Olfativa: Aroma limpio y complejo, donde destaca

LOS QUE CURAN Y LOS QUE ENVENENAN

Este libro intenta aportar al lector una mirada cuestiona- dora al ambiente que se desarrolló en las redes sociales digitales en un escenario de guerra mediática mantenido por

QUE NO EL Y LOS

o esperar la resolución expresa&#34; (artículo 94 de la Ley de procedimiento administrativo). Luego si opta por esperar la resolución expresa, todo queda supeditado a que se

I. Disposiciones generales

Gastos derivados de la recaudación de los derechos económicos de la entidad local o de sus organis- mos autónomos cuando aquélla se efectúe por otras enti- dades locales o

Algunos ​ ​de​ ​los​ ​problemas​ ​que​ ​ocasionan​ ​las​ ​Cookies

Sabemos que, normalmente, las ​cookies deben ser almacenadas y enviadas de vuelta al servidor sin modificar; sin embargo existe la posibilidad de que un atacante

Las cinco heridas que impiden ser uno mi

o que carecen de tono muscular. Es fácil imaginar al niño pequeño que al sentirse abandonado o no recibir suficiente atención, decide por cualquier medio seducir a

Algunos de los estudios que se han realizado (e.g

El tercero tiene notas bajas pero la mayor es estadística, una de las temáticas trabajadas de forma más mecánica, asimismo el último arquetipo muestra que, aun con notas buenas,

y un a no en la que el y con la que se no son y las de los A. la de " LA EL Y

Volviendo a la jurisprudencia del Tribunal de Justicia, conviene recor- dar que, con el tiempo, este órgano se vio en la necesidad de determinar si los actos de los Estados