This document outlines a project to create software that implements numerical methods through a user interface. It discusses analyzing various numerical methods like root finding, integration, differentiation, and systems of equations. The project will code these methods in Java classes and allow a user to enter a mathematical function and select which method to use. The document provides background on numerical computing and similar software, lists objectives to code methods and develop a graphical interface, and outlines a timeline to analyze, design, implement, and test each method module.
Programación 3: Ordenación topológica, matriz de caminos y algoritmo WarshallAngel Vázquez Patiño
Esta presentación le pertenece a Christian Paul Salinas
Introducción
Ordenación Topológica
Relación de Precedencia
Grafo Dirigido Aciclico
Complejidad
Pasos
Implementación del algoritmo de ordenación topológica(Ejemplo en Java)
Matriz de caminos, Algoritmo de Warshall
Matriz Cierre Transitivo
Complejidad
Ejemplo Paso a paso, e Implementación del algoritmo en Java
Propagación de Ondas (2017)
- Modelo de propagación en espacio libre
- Modelo de Tierra Plana (MTP)
- Propagación por onda de superficie
- Modelo de tierra curva
- Difracción
- Dispersión
- Propagación en entorno urbano
- Análisis del presupuesto del enlace
This calculator has been developed by me. It gives high precision results which
Normal calculator can not give. It is helpful in calculations for Space technology,
Supercomputers, Nano technology etc. I can give this calculator to interested people.
Programación 3: Ordenación topológica, matriz de caminos y algoritmo WarshallAngel Vázquez Patiño
Esta presentación le pertenece a Christian Paul Salinas
Introducción
Ordenación Topológica
Relación de Precedencia
Grafo Dirigido Aciclico
Complejidad
Pasos
Implementación del algoritmo de ordenación topológica(Ejemplo en Java)
Matriz de caminos, Algoritmo de Warshall
Matriz Cierre Transitivo
Complejidad
Ejemplo Paso a paso, e Implementación del algoritmo en Java
Propagación de Ondas (2017)
- Modelo de propagación en espacio libre
- Modelo de Tierra Plana (MTP)
- Propagación por onda de superficie
- Modelo de tierra curva
- Difracción
- Dispersión
- Propagación en entorno urbano
- Análisis del presupuesto del enlace
This calculator has been developed by me. It gives high precision results which
Normal calculator can not give. It is helpful in calculations for Space technology,
Supercomputers, Nano technology etc. I can give this calculator to interested people.
Discrete Event Simulation, CASE tool built using C#Ron Perlmuter
SimProject is a computer-aided software engineering tool that allows development of events, procedures & variables using discrete event simulation.
Graphical user interface resembles to Microsoft Visual Studio combined with Visio provides an easy and intuitive way to simulation programming.
SimProject compiles the graphical model to pseudo-code and later interpreters it using Microsoft .NET/C#.
Finally the model is executed and the simulation results are displayed in console. Debugging and step by step execution is also supported.
SimProject was built as part of our final B.Sc. project at BGU in 2005.
Introduction to MATrices LABoratory (MATLAB) as Part of Digital Signal Proces...Ahmed Gad
An introduction to MATrices LABoratory (MATLAB) as part of digital signal processing (DSP) course for allowing students to apply concepts presented in the DSP course.
This course covers the basics of MATLAB including:
MATLAB Packages
Definition
How to use a toolbox? (Java vs. MATLAB)
Examples of general and specific toolboxes
MATLAB Versions and Releases
What is MATLAB?
Overview about MATLAB Desktop
Command Window
Command History Window
Workspace Window
Current Folder Window
Editor Window
MATLAB Variables
Command Window Numeric Display Formats
MATLAB Operators and Corresponding Functions
MATLAB Documentation
Frequent Mathematical Functions
Scripting
MATLAB Comments
Matrices and vectors
MATLAB Control Structures
Figures and Plots
Find me on:
AFCIT
http://www.afcit.xyz
YouTube
https://www.youtube.com/channel/UCuewOYbBXH5gwhfOrQOZOdw
Google Plus
https://plus.google.com/u/0/+AhmedGadIT
SlideShare
https://www.slideshare.net/AhmedGadFCIT
LinkedIn
https://www.linkedin.com/in/ahmedfgad/
ResearchGate
https://www.researchgate.net/profile/Ahmed_Gad13
Academia
https://www.academia.edu/
Google Scholar
https://scholar.google.com.eg/citations?user=r07tjocAAAAJ&hl=en
Mendelay
https://www.mendeley.com/profiles/ahmed-gad12/
ORCID
https://orcid.org/0000-0003-1978-8574
StackOverFlow
http://stackoverflow.com/users/5426539/ahmed-gad
Twitter
https://twitter.com/ahmedfgad
Facebook
https://www.facebook.com/ahmed.f.gadd
Pinterest
https://www.pinterest.com/ahmedfgad/
MATLAB assignment help in computation, algorithm development, data analysis and signal processing by MATLAB experts. Also find MATLAB assignment solution for all MATLAB assignment problem.
experiences and outcomes of the internship done at VI solutions the presentation contains the brief introduction to LabVIEW and tasks fullfilled at workspace, conclusion,references
Índice
Algoritmo de INGRES…………................................................................................................ 1
Algoritmo de System R……………………………………………………………………………………………………… 3
Algoritmo R* ……………………………………………………………………………………………………………………. 5
Unleash Unlimited Potential with One-Time Purchase
BoxLang is more than just a language; it's a community. By choosing a Visionary License, you're not just investing in your success, you're actively contributing to the ongoing development and support of BoxLang.
Strategies for Successful Data Migration Tools.pptxvarshanayak241
Data migration is a complex but essential task for organizations aiming to modernize their IT infrastructure and leverage new technologies. By understanding common challenges and implementing these strategies, businesses can achieve a successful migration with minimal disruption. Data Migration Tool like Ask On Data play a pivotal role in this journey, offering features that streamline the process, ensure data integrity, and maintain security. With the right approach and tools, organizations can turn the challenge of data migration into an opportunity for growth and innovation.
Large Language Models and the End of ProgrammingMatt Welsh
Talk by Matt Welsh at Craft Conference 2024 on the impact that Large Language Models will have on the future of software development. In this talk, I discuss the ways in which LLMs will impact the software industry, from replacing human software developers with AI, to replacing conventional software with models that perform reasoning, computation, and problem-solving.
Into the Box Keynote Day 2: Unveiling amazing updates and announcements for modern CFML developers! Get ready for exciting releases and updates on Ortus tools and products. Stay tuned for cutting-edge innovations designed to boost your productivity.
In software engineering, the right architecture is essential for robust, scalable platforms. Wix has undergone a pivotal shift from event sourcing to a CRUD-based model for its microservices. This talk will chart the course of this pivotal journey.
Event sourcing, which records state changes as immutable events, provided robust auditing and "time travel" debugging for Wix Stores' microservices. Despite its benefits, the complexity it introduced in state management slowed development. Wix responded by adopting a simpler, unified CRUD model. This talk will explore the challenges of event sourcing and the advantages of Wix's new "CRUD on steroids" approach, which streamlines API integration and domain event management while preserving data integrity and system resilience.
Participants will gain valuable insights into Wix's strategies for ensuring atomicity in database updates and event production, as well as caching, materialization, and performance optimization techniques within a distributed system.
Join us to discover how Wix has mastered the art of balancing simplicity and extensibility, and learn how the re-adoption of the modest CRUD has turbocharged their development velocity, resilience, and scalability in a high-growth environment.
Globus Connect Server Deep Dive - GlobusWorld 2024Globus
We explore the Globus Connect Server (GCS) architecture and experiment with advanced configuration options and use cases. This content is targeted at system administrators who are familiar with GCS and currently operate—or are planning to operate—broader deployments at their institution.
Experience our free, in-depth three-part Tendenci Platform Corporate Membership Management workshop series! In Session 1 on May 14th, 2024, we began with an Introduction and Setup, mastering the configuration of your Corporate Membership Module settings to establish membership types, applications, and more. Then, on May 16th, 2024, in Session 2, we focused on binding individual members to a Corporate Membership and Corporate Reps, teaching you how to add individual members and assign Corporate Representatives to manage dues, renewals, and associated members. Finally, on May 28th, 2024, in Session 3, we covered questions and concerns, addressing any queries or issues you may have.
For more Tendenci AMS events, check out www.tendenci.com/events
Globus Compute wth IRI Workflows - GlobusWorld 2024Globus
As part of the DOE Integrated Research Infrastructure (IRI) program, NERSC at Lawrence Berkeley National Lab and ALCF at Argonne National Lab are working closely with General Atomics on accelerating the computing requirements of the DIII-D experiment. As part of the work the team is investigating ways to speedup the time to solution for many different parts of the DIII-D workflow including how they run jobs on HPC systems. One of these routes is looking at Globus Compute as a way to replace the current method for managing tasks and we describe a brief proof of concept showing how Globus Compute could help to schedule jobs and be a tool to connect compute at different facilities.
How Recreation Management Software Can Streamline Your Operations.pptxwottaspaceseo
Recreation management software streamlines operations by automating key tasks such as scheduling, registration, and payment processing, reducing manual workload and errors. It provides centralized management of facilities, classes, and events, ensuring efficient resource allocation and facility usage. The software offers user-friendly online portals for easy access to bookings and program information, enhancing customer experience. Real-time reporting and data analytics deliver insights into attendance and preferences, aiding in strategic decision-making. Additionally, effective communication tools keep participants and staff informed with timely updates. Overall, recreation management software enhances efficiency, improves service delivery, and boosts customer satisfaction.
Accelerate Enterprise Software Engineering with PlatformlessWSO2
Key takeaways:
Challenges of building platforms and the benefits of platformless.
Key principles of platformless, including API-first, cloud-native middleware, platform engineering, and developer experience.
How Choreo enables the platformless experience.
How key concepts like application architecture, domain-driven design, zero trust, and cell-based architecture are inherently a part of Choreo.
Demo of an end-to-end app built and deployed on Choreo.
SOCRadar Research Team: Latest Activities of IntelBrokerSOCRadar
The European Union Agency for Law Enforcement Cooperation (Europol) has suffered an alleged data breach after a notorious threat actor claimed to have exfiltrated data from its systems. Infamous data leaker IntelBroker posted on the even more infamous BreachForums hacking forum, saying that Europol suffered a data breach this month.
The alleged breach affected Europol agencies CCSE, EC3, Europol Platform for Experts, Law Enforcement Forum, and SIRIUS. Infiltration of these entities can disrupt ongoing investigations and compromise sensitive intelligence shared among international law enforcement agencies.
However, this is neither the first nor the last activity of IntekBroker. We have compiled for you what happened in the last few days. To track such hacker activities on dark web sources like hacker forums, private Telegram channels, and other hidden platforms where cyber threats often originate, you can check SOCRadar’s Dark Web News.
Stay Informed on Threat Actors’ Activity on the Dark Web with SOCRadar!
Cyaniclab : Software Development Agency Portfolio.pdfCyanic lab
CyanicLab, an offshore custom software development company based in Sweden,India, Finland, is your go-to partner for startup development and innovative web design solutions. Our expert team specializes in crafting cutting-edge software tailored to meet the unique needs of startups and established enterprises alike. From conceptualization to execution, we offer comprehensive services including web and mobile app development, UI/UX design, and ongoing software maintenance. Ready to elevate your business? Contact CyanicLab today and let us propel your vision to success with our top-notch IT solutions.
Check out the webinar slides to learn more about how XfilesPro transforms Salesforce document management by leveraging its world-class applications. For more details, please connect with sales@xfilespro.com
If you want to watch the on-demand webinar, please click here: https://www.xfilespro.com/webinars/salesforce-document-management-2-0-smarter-faster-better/
Field Employee Tracking System| MiTrack App| Best Employee Tracking Solution|...informapgpstrackings
Keep tabs on your field staff effortlessly with Informap Technology Centre LLC. Real-time tracking, task assignment, and smart features for efficient management. Request a live demo today!
For more details, visit us : https://informapuae.com/field-staff-tracking/
Why React Native as a Strategic Advantage for Startup Innovation.pdfayushiqss
Do you know that React Native is being increasingly adopted by startups as well as big companies in the mobile app development industry? Big names like Facebook, Instagram, and Pinterest have already integrated this robust open-source framework.
In fact, according to a report by Statista, the number of React Native developers has been steadily increasing over the years, reaching an estimated 1.9 million by the end of 2024. This means that the demand for this framework in the job market has been growing making it a valuable skill.
But what makes React Native so popular for mobile application development? It offers excellent cross-platform capabilities among other benefits. This way, with React Native, developers can write code once and run it on both iOS and Android devices thus saving time and resources leading to shorter development cycles hence faster time-to-market for your app.
Let’s take the example of a startup, which wanted to release their app on both iOS and Android at once. Through the use of React Native they managed to create an app and bring it into the market within a very short period. This helped them gain an advantage over their competitors because they had access to a large user base who were able to generate revenue quickly for them.
top nidhi software solution freedownloadvrstrong314
This presentation emphasizes the importance of data security and legal compliance for Nidhi companies in India. It highlights how online Nidhi software solutions, like Vector Nidhi Software, offer advanced features tailored to these needs. Key aspects include encryption, access controls, and audit trails to ensure data security. The software complies with regulatory guidelines from the MCA and RBI and adheres to Nidhi Rules, 2014. With customizable, user-friendly interfaces and real-time features, these Nidhi software solutions enhance efficiency, support growth, and provide exceptional member services. The presentation concludes with contact information for further inquiries.
In 2015, I used to write extensions for Joomla, WordPress, phpBB3, etc and I ...Juraj Vysvader
In 2015, I used to write extensions for Joomla, WordPress, phpBB3, etc and I didn't get rich from it but it did have 63K downloads (powered possible tens of thousands of websites).
4. Introducción
Este proyecto surge de la necesidad de crear una herramienta de software en la que se puedan
implementar los métodos numéricos a través de una interfaz en la que un usuario pueda
introducir una función matemática y elegir que método numérico utilizar para el propósito
que sea requerido.
Antecedentes.
Muchos problemas de cómputo en el área de matemáticas pueden ser divididos en pequeños
módulos de cálculos bien conocidos, como solución de sistemas de ecuaciones lineales,
transformadas de Fourier, etc. Por consecuencia, usualmente los programadores sólo tienen
que escribir una rutina pequeña para el problema particular que se tenga, porque ya existe
software para resolver las subtareas del problema. Facilitando así el no tener que programar
los procedimientos matemáticos una y otra vez.
Para crear proyectos relacionados con el cálculo matemático existe ya software desarrollado
como por ejemplo:
Matlab
Es un programa de cálculo numérico, orientado a matrices y vectores. Por tanto desde el
principio hay que pensar que todo lo que se pretenda hacer con él, será mucho más rápido y
efectivo si se piensa en términos de matrices y vectores.
Derive
Es un potente programa para el cálculo matemático avanzado: variables, expresiones
algebraicas, ecuaciones, funciones, vectores, matrices, trigonometría, etc. También tiene
capacidades de calculadora científica, y puede representar funciones gráficas en dos y tres
dimensiones en varios sistemas coordenados.
Geogebra.
Programa muy similar a Cabri en cuanto a instrumentos y posibilidades pero incorporando
elementos algebraicos y de cálculo. La gran ventaja sobre otros programas de geometría
5. dinámica es la dualidad en pantalla: una expresión en la ventana algebraica se corresponde
con un objeto en la ventana geométrica y viceversa. Es un programa libre y gratuito, GNU
General Public License.
Euler
Es un potente laboratorio numérico e interactivo. Evalúa rápidamente funciones numéricas,
visualiza los resultados, y permite probar y programar algoritmos numéricos. El sistema
puede manejar números reales, complejos y de intervalos, vectores y matrices. La mayoría
de las rutinas están escritas en lenguaje de Euler y pueden ser modificados o ampliados por
el usuario.
Yacas
Es una herramienta de álgebra fácil de usar, un programa para la manipulación simbólica de
expresiones matemáticas. Utiliza su propio lenguaje de programación. El sistema cuenta con
una biblioteca de scripts que implementan muchas de las operaciones de álgebra simbólica;
nuevos algoritmos pueden ser fácilmente añadidos a la biblioteca. Yacas viene con una
amplia documentación (cientos de páginas) que cubren el lenguaje de script, la funcionalidad
que ya está implementada en el sistema, y los algoritmos que hemos utilizado.
Octave
Proporciona una cómoda interfaz de línea de comandos para resolver numéricamente
problemas lineales y no lineales, y realiza otros experimentos numéricos usando un lenguaje
compatible con Matlab.
6. Objetivos.
Objetivo general
En este proyecto se pretende transformar los procedimientos matemáticos involucrados en la
resolución de los diferentes métodos numéricos, a rutinas de código que permitan la
resolución de problemas matemáticos usando una herramienta de cómputo.
Objetivos específicos
Codificar los métodos numéricos para implementarse en software
Crear una interfaz de usuario para ingresar una función matemática en el ordenador
y seleccionar el método de resolución correspondiente.
Identificar los procedimientos matemáticos que puedan resolverse a través de un
método numérico.
Desarrollar una interfaz gráfica fácil de usar para el usuario final.
Metodología.
Para el presente proyecto se usará el lenguaje de programación JAVA, que cuenta con las
librerías necesarias para su desarrollo tales como Math, la cual contiene lo necesario para
operar con funciones matemáticas y hacer procesos como el redondeo de cifras.
La metodología a usar para el desarrollo del software será la metodología de prototipos, que
consiste en las fases de:
1. Planeación
2. Modelado
3. Elaboración del prototipo
4. Desarrollo posterior
5. Entrega y retroalimentación
6. Comunicación con el cliente
El modelo de prototipos tiene la ventaja de acelerar el desarrollo del software ya que la fase
de planeación y modelado es más rápida al ser el software un prototipo. En las fases de
elaboración y desarrollo se toma el tiempo que sea necesario para que en la entrega y
7. retroalimentación se pueda presentar una versión del proyecto que aunque no terminado sea
ya funcional para que el cliente pueda hacer sus observaciones y esté al tanto del progreso
del proyecto. En base a este análisis del cliente se puede volver a iterar la planeación y
siguientes fases hasta volver a presentar un nuevo prototipo y así llegar a un producto final
que satisfaga las necesidades del cliente.
Recursos.
Siendo JAVA el lenguaje de programación a utilizar se empleara una computadora con los
requerimientos básicos para poder utilizar la máquina virtual de java así como un entorno de
desarrollo integrado, el cual será BlueJ ya que integra una interfaz desde la cual se pueden
ver las relaciones entre los diferentes módulos o clases programadas.
Java Runtime Environment (JRE) es lo que se obtiene al descargar el software de Java. JRE
está formado por Java Virtual Machine (JVM), clases del núcleo de la plataforma Java y
bibliotecas de la plataforma Java de soporte.
El sistema operativo que alojara la JVM será Windows 10, para lo cual se requieren
RAM: 128 MB
Espacio en disco: 124 MB para JRE; 2 MB para Java Update
Procesador: Mínimo Pentium 2 a 266 MHz
BlueJ fue desarrollado para apoyar la enseñanza y el aprendizaje de la programación
orientada a objetos, y como resultado, su diseño difiere de otros entornos de desarrollo. La
pantalla principal muestra gráficamente la estructura de clases de una aplicación en desarrollo
(en un diagrama muy parecido a UML), y los objetos pueden ser creados y probados
interactivamente. Combinado con una interfaz de usuario simple, esta facilidad de
interacción permite experimentar de manera fácil con los objetos en desarrollo. Los
conceptos de la orientación a objetos (clases, objetos, comunicación a través de llamadas
a métodos) son representados visualmente en el diseño de interacción en la interfaz.
8. Para la codificación del software se requieren conocimientos básicos de las librerías
matemáticas integradas para el lenguaje de programación, y conocimientos básicos de
matemáticas con su implementación en software por parte del desarrollador del proyecto.
Cronograma
Semana 1
7/09/2020-
13/09/2020
Semana 2
14/09/2020-
20/09/2020
Semana 3
21/09/2020-
27/09/2020
Semana 4
28/09/2020-
04/10/2020
Realizado
Definiciónde
antecedentes,
objetivos,
metodologíay
recursosa usar.
X
Creaciónde una clase
de análisisléxico que
recibacadenasde
textoy lasconvierta
enexpresiones
matematicas
X
Programaciónde un
módulodel software
para redondearcifras
Solución de ecuaciones
Punto fijo
Análisisdel método
del puntofijo X
Diseñodel algoritmo,
clases, interfazy
métodospara
programar el modulo
del puntofijo.
X
Programaciónde las
clasespreviamente
diseñadas
X
Pruebasdel software
usandofuncionescon
resultadosconocidos
y herramientasde
graficación
X
Bisección
Análisisdel método
de la bisección X
Diseñodel algoritmo,
clases,interfazy X
9. métodospara
programar el módulo
de la bisección.
Programaciónde las
clasespreviamente
diseñadas
X
Pruebasdel software
usandofuncionescon
resultadosconocidos
y herramientasde
graficación
X
Falsa posición
Análisisdel método
de la falsaposición X
Diseñodel algoritmo,
clases,interfazy
métodospara
programar el módulo
de la falsaposición.
X
Programaciónde las
clasespreviamente
diseñadas
X
Pruebasdel software
usandofuncionescon
resultadosconocidos
y herramientasde
graficación
X
Semana 5
5/10/2020-
11/10/2020
Semana 6
12/10/2020-
18/10/2020
Semana 7
19/10/2020-
25/10/2020
Semana 8
26/10/2020-
1/11/2020
Newton Raphson
Análisisdel método
de Newton-Raphson X
Diseñodel algoritmo,
clases,interfazy
métodospara
programar el módulo
de Newton-Raphson.
X
Programaciónde las
clasespreviamente
diseñadas
X
Pruebasdel software
usandofuncionescon
resultadosconocidos
y herramientas de
graficación
X
10. Secante
Análisisdel método
de Secante X
Diseñodel algoritmo,
clases,interfazy
métodospara
programar el módulo
de Secante.
X
Programaciónde las
clasespreviamente
diseñadas
X
Pruebasdel software
usandofunciones con
resultadosconocidos
y herramientasde
graficación
X
Sistemas de ecuaciones
Método de Jacobi
Análisisdel método
de Jacobi. X
Diseñodel algoritmo,
clases,interfazy
métodospara
programar el módulo
de Jacobi.
X
Programaciónde las
clasespreviamente
diseñadas
X
Pruebasdel software
usandosistemasde
ecuacionescon
resultadosconocidos
y comprobaciónde
resultados
X
Método de Gauss- Seidel
Análisisdel método
de Gauss-Seidel. X
Diseñodel algoritmo,
clases,interfaz y
métodospara
programar el módulo
de Gauss-Seidel.
X
Programaciónde las
clasespreviamente
diseñadas
X
11. Pruebasdel software
usandosistemasde
ecuacionescon
resultadosconocidos
y comprobaciónde
resultados
X
Semana 9
2/11/2020-
8/11/2020
Semana 10
9/11/2020-
15/11/2020
Semana 11
2/11/2020-
8/11/2020
Semana 12
16/11/2020-
22/11/2020
Integración y derivación numérica
Método del trapecio
Análisisdel método
de trapecio. X
Diseñodel algoritmo,
clases,interfazy
métodos para
programar el módulo
de trapecio.
X
Programaciónde las
clasespreviamente
diseñadas
X
Pruebasdel software
usandointegralescon
resultadosconocidos
y comparando
resultados.
X
Método de Simpson
Análisisdel método
de Simpson. X
Diseñodel algoritmo,
clases,interfazy
métodospara
programar el módulo
de Simpson.
X
Programaciónde las
clasespreviamente
diseñadas
X
Pruebasdel software
usandointegralescon
resultadosconocidos
y comparando
resultados.
X
Derivación numérica
Análisisdel método
de derivación X
12. progresiva,regresivay
central.
Diseñodel algoritmo,
clases,interfazy
métodospara
programar los
métodosde
derivación
X
Programaciónde las
clasespreviamente
diseñadas
X
Pruebasdel software
usandoderivadascon
resultadosconocidos
y comparando
resultados.
X
Semana 13
23/11/2020-
29/11/2020
Semana 14
30/12/2020-
6/12/2020
Semana 15
7/12/2020-
13/12/2020
Semana 16
14/12/2020-
20/12/2020
Ajuste de datos
Regresión lineal por mínimos cuadrados
Análisisdel método
de mínimos
cuadrados.
X
Diseñodel algoritmo,
clases,interfazy
métodospara
programar el método
de losmínimos
cuadrados
X
Programaciónde las
clasespreviamente
diseñadas
X
Pruebasdel software
usandopuntos
cartesianosy
comparandola recta
obtenidaconlos
puntosgraficados
X
Integraciónde los
métodos
programadosenuna
solainterfaz.
X
13. Programación de analizador léxico y herramienta de
redondeo
Análisis Lexico
Un analizador léxico o analizador lexicográfico (en inglés scanner) es la primera fase de
un compilador, consistente en un programa que recibe como entrada el código fuente de otro
programa (secuencia de caracteres) y produce una salida compuesta de tokens (componentes
léxicos) o símbolos. Estos tokens sirven para una posterior etapa del proceso de traducción,
siendo la entrada para el analizador sintáctico (en inglés parser).
La especificación de un lenguaje de programación a menudo incluye un conjunto de reglas
que definen el léxico. Estas reglas consisten comúnmente en expresiones regulares que
indican el conjunto de posibles secuencias de caracteres que definen un token o lexema.
En algunos lenguajes de programación es necesario establecer patrones para caracteres
especiales (como el espacio en blanco) que la gramática pueda reconocer sin que constituya
un token en sí.
Para la correcta lectura de las funciones que serán evaluadas en los siguientes modulos del
programa se hizo la programación de un analizador léxico que recibe una cadena de texto y
convierta la cada en una operación matemática que el lenguaje java pueda interpretar.
Las funciones que acepta el lenguaje definido en el analizador léxico son, seno, coseno,
tangente, e, logaritmo, raíz cuadrada, suma, resta, multiplicación, división, potencia y el
agrupamiento de operaciones mediante paréntesis.
Raiz cuadrada sqrt()
seno sen()
coseno cos()
tangente tan()
e eˆ()
logaritmo ln()
suma, resta, multiplicación, división. + , - , / , *
Potencia o “ elevado a “
ˆ
Para el caso de e, la cadena se recibe como eˆ y se hace un filtrado para reemplazar el
carácter por los paréntesis que ocupa el lenguaje del analizador léxico, lo mismo ocurre con
variables x, ya que no se ha definido que operación realizaría x, el filtrado susituye x por su
correspondiente valor numérico previamente pasado como un parámetro, asi se maneja x
como si de un numero se tratara. Asi mismo, al recibir un resultado puede darse el caso de
ser devuelto en una nomenclatura tipo E’algun numero’, lo cual indica que hay un
desbordamiento por el numero de decimales que se están manejando, sin embargo el
14. analizador léxico no procesa este operador asi que en el filtrado de la función también se
sustituye por "*10^" lo cual es su verdadero significado.
Asi entonces el usuario puede introducir libremente cadenas de texto de la forma “(e^(-
0.5*x)) * cos(2*x) “ . Al leer la función también se debe enviar como parámetro el valor de
la variable x. En el caso de un error de sintaxis el resultado de la función será 0, ya que
devuelve la variable double resultado, la cual desde su declaración se le dio el valor 0.
Los errores en la sintaxis de la cadena pueden deberse a introducir un operador no definido
en el analizador léxico, una función no definida por este, o un carácter invalido o no
coherente con una expresión matemática.
Diseño UML
15. Implementación
Código del analizador léxico de funciones matemáticas
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import javax.swing.JOptionPane;
public class EvaluadorFunciones {
public static double eval(final String str) {
return new Object() {
int pos = -1, ch;
void nextChar() {
ch = (++pos < str.length()) ? str.charAt(pos) : -1;
}
boolean eat(int charToEat) {
while (ch == ' ') nextChar();
if (ch == charToEat) {
nextChar();
return true;
}
return false;
}
double parse() {
nextChar();
double x = parseExpression();
if (pos < str.length()) throw new RuntimeException("Unexpected: " +
(char)ch);
return x;
}
// Grammar:
// expression = term | expression `+` term | expression `-` term
// term = factor | term `*` factor | term `/` factor
// factor = `+` factor | `-` factor | `(` expression `)`
// | number | functionName factor | factor `^` factor
16. double parseExpression() {
double x = parseTerm();
for (;;) {
if (eat('+')) x += parseTerm(); // addition
else if (eat('-')) x -= parseTerm(); // subtraction
else return x;
}
}
double parseTerm() {
double x = parseFactor();
for (;;) {
if (eat('*')) x *= parseFactor(); // multiplication
else if (eat('/')) x /= parseFactor(); // division
else return x;
}
}
double parseFactor() {
if (eat('+')) return parseFactor(); // unary plus
if (eat('-')) return -parseFactor(); // unary minus
double x;
int startPos = this.pos;
if (eat('(')) { // parentheses
x = parseExpression();
eat(')');
} else if ((ch >= '0' && ch <= '9') || ch == '.') { // numbers
while ((ch >= '0' && ch <= '9') || ch == '.') nextChar();
x = Double.parseDouble(str.substring(startPos, this.pos));
} else if (ch >= 'a' && ch <= 'z') { // functions
while (ch >= 'a' && ch <= 'z') nextChar();
String func = str.substring(startPos, this.pos);
x = parseFactor();
if (func.equals("sqrt")) x = Math.sqrt(x);
else if (func.equals("sen")) x = Math.sin(x);
else if (func.equals("cos")) x = Math.cos(x);
else if (func.equals("tan")) x = Math.tan(Math.toRadians(x));
else if (func.equals("e")) x = Math.exp(x);
else if (func.equals("ln")) x = Math.log(x);
else throw new RuntimeException("Unknown function: " + func);
} else {
throw new RuntimeException("Unexpected: " + (char)ch);
17. }
if (eat('^')) x = Math.pow(x, parseFactor()); // exponentiation
// if (eat('e^')) x = Math.pow(x, parseFactor()); //numeros tipo 434E-10
return x;
}
}.parse();
}
}
Código de la clase de filtrado para funciones que incluyen una variable x
import javax.swing.JOptionPane;
public class EvaluarX{
public double evaluarFuncion(String funcion,double x){
// String sustitucionx= funcion.replaceAll("x",String.valueOf(x));
// sustitucionx= sustitucionx.replaceAll("E","*10^");
// sustitucionx= sustitucionx.replaceAll("e^","e");
String sustitucion="";
sustitucion=funcion.replace("e^","e");
sustitucion=sustitucion.replaceAll("x",String.valueOf(x));
sustitucion=sustitucion.replaceAll("E","*10^");
//sustitucion=sustitucion.replaceAll("E","^");
// funcion.replaceAll("e^","e");
//System.out.println(sustitucion);
EvaluadorFunciones EF= new EvaluadorFunciones();
double resultado=0.0;
try{
resultado=EF.eval(sustitucion);
}catch(Exception excepcion)
{
//JOptionPane.showMessageDialog(null, "error de
sintaxis", " ", JOptionPane.WARNING_MESSAGE);
}
19. Redondeo
Debido a que será una operación muy repetitiva en todos los modulos del programa se creo
una clase que implementara el método de redondeo, la clase recibe como parámetros un
número y un numero de decimales, y devuelve un resultado redondeando el numero a su
entero decimal más cercano.
UML
Implementacion
Clase redondeo
public class Redondeo {
public double redondear(double numero,int digitos)
{
int cifras=(int) Math.pow(10,digitos);
return Math.rint(numero*cifras)/cifras;
}
}
20. Soluciónde ecuaciones
Análisis
Encontrar una solución ó una raíz real de una ecuación,
es hallar el valor de la variable independiente x, que anule
el valor de la función f(x), que se exprese en términos de
la variable citada. En otras palabras, si la función se
desarrolla en el plano cartesiano xy, la solución real de
esa función es el valor de x que corresponda a la
intersección del eje de las abscisas con la curva d efinida
por la función f(x).
Para encontrar una solución real, las ecuaciones, sin
importar que representen un polinomio u otra cualquiera, deben ser representadas en la
forma: f(x) = 0
Punto fijo
A partir de una ecuación F(X)=0 se genera una ecuación X=g(X), a la cual se le busca una
solución, y se debe tener en cuenta lo siguiente
Se busca un valor de X que al reemplazarlo en g, el resultado sea X.
Se debe elegir una aproximación inicial Xo
Se calcula X1=g(Xo)
Y se repite el paso anterior hasta llegar a una aproximación.
Puede afirmarse que si el método converge, la diferencia en valor absoluto entre valores
proporcionados en dos iteraciones sucesivas será cada vez más pequeña a medida que n
aumente, y con esto se tendrá un criterio para saber cuándo termina la aplicación del método.
Sea f(x) = 0 una ecuación algebraica o trascendente cualquiera. Se suma x en ambos
miembros y se obtiene:
(1)
f(x) + x = x
21. Donde el miembro izquierdo es otra
función de x que se define como
(2)
G(x) + x = x
Se sustituye en la ecuación (1):
(3)
x = G(x)
Si x = a es una raíz de la ecuación,
entonces
f (a) = 0
Al proceder reiteradamente en esta forma se induce que la n-ésima aproximación es:
Xn = G(Xn-1)
n = 1,2,3,.....
22. Diseño
Diagrama de flujodel métododel punto fijo.
Pseudocódigodel métodode punto fijo
Proceso Método punto Fijo
Leer Xo, Tolerancia, Iter
Yo = f(Xo)
Contador = 0
Error = Tolerancia + 1
Mientras 0 & Error > Tolerancia Hacer
Yo = f(Xn)
Error = abs ((Xn - Xo)/Xn)
Xo = Xn
Contador = Contador + 1
Fin Mientras
Si Yo = 0 Entonces
Muestre: ‘Xo es Raiz’
Sino Si Error < Tolerancia Entonces
Muestre: ‘‘Xo’ es una raiz aproximada con una tolerancia ‘Tolerancia’’
Fin Si
Fin Si
Fin Proceso
28. //________________________________________________
}
public JPanel interfazpuntofijo() {
return panel3;
}
public void actionPerformed(ActionEvent mn){
if(mn.getSource()==btn_puntofijo){
String funcion;
Double inicial=0.0;
Double error=0.0;
int decimales=0;
funcion=txt_puntofijo.getText();
funcion=funcion.replaceAll(" ", ""); //quitar espacios
try{
inicial=Double.parseDouble(txt_valorinicial.getText());
} catch (NumberFormatException nfe){
JOptionPane.showMessageDialog(null, "Ingrese un valor numerico", "Valor inicial",
JOptionPane.WARNING_MESSAGE);}
error=Double.parseDouble(cotaerror.getSelectedItem().toString());
29. decimales=Integer.parseInt(numdecimales.getSelectedItem().toString());
if(funcion.length()!=0){
PuntoFijo pf = new PuntoFijo();
textarea_puntofijo.setText(pf.puntofijo(funcion,inicial,error,decimales));
}else{
// System.out.print("hola");
JOptionPane.showMessageDialog(null, "La función no ha sido creada", "Casilla vacia
", JOptionPane.WARNING_MESSAGE);}
}
if(mn.getSource()==limpiar_puntofijo){
textarea_puntofijo.setText("");
}
}
// public static void main(String[] args) {
// Puntofijo2 MN = new Puntofijo2();
30. // }
}
La clase punto fijo recibe una función, un valor inicial, un margen de error y con cuantos
decimales debe trabajar y devuelve un String que se añadirá al área editable de la interfaz
gráfica .
Clase que implementa el método del punto fijo
public class PuntoFijo{
String consola="";
double error;
double errorRelativo;
double erp;
public String puntofijo(String funcion,double x,double margen,int decimales) {
EvaluarX EX=new EvaluarX();
Redondeo R= new Redondeo();
int cifras=decimales;
//String funcion = "(e(x))/3";
error= margen + 1;
double resultado=0;
consola+="XttFuncion(x)ttError";
consola+="n";
//while (erp>margen){
while (error>margen){
31. try{
resultado= R.redondear((EX.evaluarFuncion(funcion,x)),cifras);
//if(resultado==Infinity);
error= Math.abs(resultado-x);
error =R.redondear(error,cifras);
consola+=""+x+"tt"+resultado+"tt"+error;
consola+="n";
// System.out.println(""+x+"tt"+resultado+"tt"+error+"n");
x=resultado;
} catch (Exception e){}
}
return consola;
}
// public static void main (String [] args){
// PuntoFijo pf= new PuntoFijo();
// pf.puntofijo("(e^x)-(10*(x^2))+2",1.0,0.0001,5);
// }
}
Pruebas
La función f(𝑥) = 𝑒𝑥
– 3 x
De la forma x= 𝑒𝑥
/3
Valor inicial= 0.5 ERP= 0.001 % 5 decimales de redondeo
Arroja un valor para x =0.61904 que se aproxima a la raíz de la función como lo muestra la
gráfica de la función
32. Graficando f(𝑥) = 𝑒𝑥
– 3 x se obtiene la siguiente grafica que confirma la aproximación de
la raíz
33. Método de bisección
Análisis
Este método plantea que si se cumple que:
f(x) es real y continua en el intervalo que va desde un Xi hasta un Xs
f(Xi) f(Xs)<0
Si se cumple lo anterior, por lo menos existe una raíz dentro de este intervalo.
El procedimiento es el siguiente:
Se elige un intervalo inicial para función f(x)
Luego se busca localizar la raíz con mayor
exactitud dentro del intervalo dividiendo a la
mitad y observando si se conservan las
condiciones iniciales.
Se compara el Xmed con cada uno de los
límites del intervalo y se observa que
producto cambia de signo y se asigna un
nuevo intervalo.
Se vuelve a repetir el proceso, y se va
poniendo pequeño el intervalo hasta llegar a
una aproximación de la raíz o la raíz exacta.
Al aplicarse el método se puede apreciar que la
aproximación a la raíz mejora cada vez que el
intervalo se hace más pequeño.
35. Pseudocódigo del método de la bisección
Proceso Metodo de Biseccion
Leer Xi, Xs, Tolerancia, Iter
Yi = f(Xi)
Ys = f(Xs)
Si Yi*Ys < 0 Entonces
Xm= (Xi + Xs)/2
Contador = 1
Ym = f(Xm)
Error = Tolerancia + 1
Mientras Hacer
Si Yi*Ym < 0 Entonces
X s= Xm
Ys = Ym
Sino
X i= Xm
Yi = Ym
Fin Si
Xaux = Xm
Xm = (Xi + Xs)/2
Ym = f(Xm)
Error = Abs(Xm - Xaux)
Contador = Contador + 1
Fin Mientras
36. Si Ym = 0 Entonces
Muestre:‘Xm es Raiz’
Sino Si Error < Tolerancia Entonces
Muestre:‘Xm es aproximacion a una raiz con una toleracia ‘Tolerancia’’
Fin Si
Fin Si
Sino
Muestre:‘El intervalo es inadecuado’
Fin Si
Fin Proceso
42. //_________________________________________//
}
public void actionPerformed(ActionEvent mn){
if(mn.getSource()==btn_biseccion){
String funcion;
Double a=0.0;
Double b=0.0;
Double error=0.0;
int decimales=0;
funcion=txt_biseccion.getText();
funcion=funcion.replaceAll(" ", ""); //quitar espacios
try{
a=Double.parseDouble(txt_valorabiseccion.getText());
} catch (NumberFormatException nfe){
JOptionPane.showMessageDialog(null, "Ingrese un valor numerico", "Valor
inicial", JOptionPane.WARNING_MESSAGE);}
try{
b=Double.parseDouble(txt_valorbbiseccion.getText());
} catch (NumberFormatException nfe){
JOptionPane.showMessageDialog(null, "Ingrese un valor numerico", "Valor
inicial", JOptionPane.WARNING_MESSAGE);}
error=Double.parseDouble(cotaerror.getSelectedItem().toString());
decimales=Integer.parseInt(numdecimales.getSelectedItem().toString());
43. if(funcion.length()!=0){
Biseccion bi = new Biseccion();
textarea_biseccion.setText(bi.biseccion(funcion,a,b,error,decimales));
}else{
JOptionPane.showMessageDialog(null, "La función no ha sido creada", "Casilla
vacia ", JOptionPane.WARNING_MESSAGE);}
}
if(mn.getSource()==limpiar_biseccion){
textarea_biseccion.setText("");
}
}
public JPanel interfazbiseccion() {
return panel2;
}
}
44. La clase Bisección recibe una función, un valor inicial a, el valor inicial b, un margen de
error y con cuantos decimales debe trabajar y devuelve un String que se añadirá al área
editable de la interfaz gráfica .
Clase que implementa el método de la bisección
import javax.swing.*;
import java.awt.Event.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class Interfaz_Biseccion extends JFrame implements ActionListener{
//___________________________
JPanel panel2;
JTextField txt_biseccion;
JButton btn_biseccion;
JLabel lbl_biseccion;
JTextArea textarea_biseccion;
JScrollPane scrollpane_biseccion;
JButton limpiar_biseccion;
JTextField txt_errorbiseccion;
JLabel lbl_errorbiseccion;
JTextField txt_decimalesbiseccion;
JLabel lbl_decimalesbiseccion;
JTextField txt_valorabiseccion;
JLabel lbl_valorabiseccion;
JTextField txt_valorbbiseccion;
JLabel lbl_valorbbiseccion;
51. Falsa posición
Análisis
Si se tiene dos puntos (a, f(a)) y(b, f(b)) y se traza la recta que une a estos dos
puntos, se puede observar que un punto esta por debajo del eje x y otro por encima
de este, y un punto intermedio (Xm,0), con este punto intermedio se puede
comparar los límites y obtener un nuevo intervalo
Si f(A) y f(B)<0, entonces la raíz
se encuentra al lado izquierdo del
intervalo.
Si f(A) y f(B)>0, entonces la raíz
se encuentra al lado derecho del
intervalo.
Para hallar la intersección de la
recta con el eje X usamos la siguiente fórmula:
Xm= a - ((f(a)*(b - a))/(f(b) - f(a)))
53. Pseudocódigodel métodode la falsa posición
Proceso Método de la falsa posición
Leer Xi, Xs, Tolerancia, Iter
Yi = f(Xi)
Ys = f(Xs)
Si Yi*Ys < 0 Entonces
Xm= Xi – ((Yi*(Xs – Xi))/(Ys – Yi))
Contador = 1
Ym = f(Xm)
Error = Tolerancia + 1
Mientras Hacer
Si Yi*Ym < 0 Entonces
X s= Xm
Ys = Ym
Sino
X i= Xm
Yi = Ym
Fin Si
Xaux = Xm
Xm= Xi – ((Yi*(Xs – Xi))/(Ys – Yi))
Ym = f(Xm)
54. Error = Abs(Xm - Xaux)
Contador = Contador + 1
Fin Mientras
Si Ym = 0 Entonces
Muestre:‘Xm es Raiz’
Sino Si Error < Tolerancia Entonces
Muestre:‘Xm es aproximacion a una raiz con una toleracia ‘Tolerancia’’
Fin Si
Fin Si
Sino
Muestre:‘El intervalo es inadecuado’
Fin Si
Fin Proceso
61. JOptionPane.showMessageDialog(null, "Ingrese un valor numerico", "Valor inicial",
JOptionPane.WARNING_MESSAGE);}
try{
b=Double.parseDouble(txt_valorbfalsaposicion.getText());
} catch (NumberFormatException nfe){
JOptionPane.showMessageDialog(null, "Ingrese un valor numerico", "Valor inicial",
JOptionPane.WARNING_MESSAGE);}
error=Double.parseDouble(cotaerror.getSelectedItem().toString());
decimales=Integer.parseInt(numdecimales.getSelectedItem().toString());
if(funcion.length()!=0){
FalsaPosicion f= new FalsaPosicion();
textarea_falsaposicion.setText(f.falsaPosicion(funcion,a,b,error,decimales));
}else{
JOptionPane.showMessageDialog(null, "La función no ha sido creada", "Casilla vacia
", JOptionPane.WARNING_MESSAGE);}
}
if(mn.getSource()==limpiar_falsaposicion){
textarea_falsaposicion.setText("");
}
}
}
62. La clase FalsaPosicion recibe una función, un valor inicial a, el valor inicial b, un margen
de error y con cuantos decimales debe trabajar y devuelve un String que se añadirá al área
editable de la interfaz gráfica .
Clase que implementa el método
public class FalsaPosicion {
public String consola="";
public String falsaPosicion(String funcion,double a, double b, double tolerancia,
int decimales){
consola+="METODO DE LA FALSA POSICIONn";
consola+="nx"+"t"+"f(x)t"+"error"+"n";
//_________________________
//double a=0;
//double b=1;
//double tolerancia=0.0001;
//int decimales=6;
// String funcion= "10*e(-0.5*x)*cos(2*x)";
//String funcion= "(5*(x^ 3))-(5*(x^2))+(6 * x)-2";
//String funcion="(0.05*x)-(sen(x))";
//_________________________
Redondeo R= new Redondeo();
EvaluarX EX=new EvaluarX();
double funcionA,funcionB,funcionC=0;
double error=tolerancia+1;
double c=0;
double cAnterior=c;
int contador=0;
funcionA=R.redondear((EX.evaluarFuncion(funcion,a)),decimales);
funcionB=R.redondear((EX.evaluarFuncion(funcion,b)),decimales);
if ((funcionA * funcionB)<0)
{
while(error>=tolerancia){
consola+="________________________________________________";
consola+="n";
63. cAnterior=c;
funcionA=R.redondear((EX.evaluarFuncion(funcion,a)),decimales);
funcionB=R.redondear((EX.evaluarFuncion(funcion,b)),decimales);
c=a - (((b-a)* funcionA)/(funcionB-funcionA)) ;
c=R.redondear(c,decimales);
funcionC= EX.evaluarFuncion(funcion,c);
funcionC=R.redondear(funcionC,decimales);
// error= Math.abs((Math.abs(c)-Math.abs(cAnterior))/Math.abs(c)) * 100;
//eap
error= Math.abs(Math.abs(c)-Math.abs(cAnterior)); //ea
error=R.redondear(error,decimales);
//if(error>=tolerancia){
consola+=c+"t"+funcionC+"tt"+error;
consola+="n";
// }
if(c==0) error=tolerancia-1; //para detener el ciclo
contador++;
if((funcionA*funcionC)<0){
b=c;
}
else {
a=c;
}
}
} else{consola+= " f(a) * f(b) es mayor que 0 n Introduzca nuevos valores de a
y b";}
return consola;
}
64. }
Pruebas
La función f(x)= 𝑒−𝑥
–lnx se evaluó con a=0.5 y b=2, con un error absoluto porcentual de
0.001 y 5 decimales
El método seleccionado fue el de la falsa posición.
66. Newton Raphson
Análisis
Este método de resolución numérica busca un cero de la función f(x) por aproximaciones
sucesivas a partir de un valor inicial x0. El valor sucesivo xn+1 es la abscisa del punto en
que la tangente a la gráfica de f(x) en xn corta al eje Ox. Es decir
Es por tanto equivalente a aplicar el método de iteraciones a la función
Este método es uno de los más utilizados para localizar raíces ya que en general es muy
eficiente y siempre converge para una función polinomial.
Se requiere que las funciones sean diferenciables, y por tanto, continuas, para poder aplicar
este método.
Se debe partir de un valor inicial para la raíz: xi , este puede ser cualquier valor, el método
convergirá a la raíz mas cercana.
Si se extiende una tangente desde el punto , el punto donde esta tangente cruza al
eje x representa una aproximación mejorada de la raíz.
67. El método de Newton-Raphson es convergente
cuadráticamente, es decir, el error es
aproximadamente al cuadrado del error anterior.
Esto significa que el número de cifras decimales
correctas se duplica aproximadamente en cada
interacción.
Pseudocódigo
1. Inicio
2. Ingreso función, Ingreso derivada función, Ingreso tolerancia desdeada e ingreso de
una aproximación.
3. Procesamiento de datos y conversíon de las entradas en variables.
4. Mientras que el valor absoluto de la f(xinicial)>tolerancia
5. Xin1= xin-f(xin)/f’(xin)
6. Xin= Xin1
7. Cierre condiciones
8. Mostrar raíz (Xin)
9. Fin
75. Clase que obtiene laderivada encada iteración del método
publicclass Derivada{
public double obtenerDerivada(Stringfuncion,double x0,intdecimales) {
//String funcion= " x ^ 2";
// double x0 = 1.0;
double h= 0.001;
EvaluarX EX = new EvaluarX();
double funcionx0mash=EX.evaluarFuncion(funcion,(x0+h));
double funcionx0menosh=EX.evaluarFuncion(funcion,(x0-h));
double centrada = (funcionx0mash-funcionx0menosh) /(2*h);
Redondeor = new Redondeo();
return r.redondear(centrada,decimales); }
// publicstatic voidmain (String [] args) {
// Derivada d = new Derivada ();
// System.out.println(d.obtenerDerivada("(e^x)-((10*x)^2)+2",0.0,4));
// }
}
76. Pruebas
La función es ((e^(-x/4))* (2 - x)) – 1 con un valor inicial =0
La raíz obtenidaes0.57836 que corresponde conlagrafica
77. Método de la secante
Análisis
El principal inconveniente del método de Newton estriba en que requiere conocer el valor de
la primera derivada de la función en el punto. Sin embargo, la forma funcional de f(x)
dificulta en ocasiones el cálculo de la derivada. En estos casos es más útil emplear el método
de la secante.
El método de la secante parte de dos puntos (y no sólo uno como el método de Newton) y
estima la tangente (es decir, la pendiente de la recta) por una aproximación de acuerdo con
la expresión:
Sustituyendo esta expresión en la ecuación del método de Newton, obtenemos la expresión
del método de la secante que nos proporciona el siguiente punto de iteración:
78. En la siguiente iteración, emplearemos los puntos x1 y x2para estimar un nuevo punto más
próximo a la raíz de acuerdo con la ecuación .En la figura se representa geométricamente
este método.
En general, el método de la secante presenta las mismas ventajas y limitaciones que el método
de Newton-Raphson explicado anteriormente.
Diseño
PSEUDOCÓDIGO MÉTODO DE LA SECANTE
Proceso Metodo de la Secante
Leer X1, Xo, Tolerancia, Iter
Yo = f(Xo)
Si Yo = 0 Entonces
Muestre: ‘Xo es Raiz’
Sino
Y1 = f(X1)
Contador = 0
Error = Tolerancia + 1
Mientras Hacer
79. X2 = X1 – ((Y1*(X1 Xo))/Den)
Error = Abs((X2 – X1)/ X2)
Xo = X1
Yo = Y1
X1 = X2
Y1 = f(X1)
Contador = Contador + 1
Fin Mientras
Si Y1 = 0 Entonces
Muestre: ‘X1 es Raiz’
Sino Si Error < Tolerancia Entonces
Muestre: ‘‘X1’ es una raiz aproximada con una tolerancia ‘Tolerancia’’
Sino Si Den= 0 Entonces
Muestre: ‘Hay posiblemente una raiz múltiple’
Sino
Muestre: ‘Fracaso en ‘Iter’ iterraciones’
Fin Si
Fin Si
Fin Si
Fin Si
Fin Proceso
91. Sistemas de ecuaciones lineales
Análisis
En matemáticas y álgebra lineal, un sistema de ecuaciones lineales, también conocido
como sistema lineal de ecuaciones o simplemente sistema lineal, es un conjunto
de ecuaciones lineales (es decir, un sistema de ecuaciones en donde cada ecuación es de
primer grado), definidas sobre un cuerpo o un anillo conmutativo.
Método de Jácobi
El método de Jácobi es un método iterativo con el cual se resuelve el sistema lineal
Ax = b
Comienza con una aproximación inicial x(0) a la solución x y genera una sucesión de
vectores x(k) que convergen a la solución x.
Un sistema de ecuaciones algebraicas lineales es un conjunto de ecuaciones de la forma:
:: :: ::
O bien en su forma matricial:
Que a su vez se puede expresar como:
92. Ax = b
Donde “A” es la matriz de coeficientes, x es el vector de incógnitas y b el vector de
términos independientes.
La solución del sistema de ecuaciones es un conjunto de n valores que
satisfacen simultáneamente todas las ecuaciones.
En la solución de estos problemas pueden presentarse 3 casos:
1.- Solución única Sistema compatible determinado.
2.- Mas de una solución Sistema compatible e indeterminado.
(numero infinito de soluciones)
3.- Sin solución Sistema incompatible.
Ilustrando el método de Jácobi con un sistema de ecuaciones de 3x3, si el vector:
Es el vector aproximación a la solución x después de k iteraciones, entonces se tiene que
para la siguiente aproximación:
106. Redondeo R= new Redondeo();
double xn[]= new double [tam];
for ( int i =0 ; i< tam ; i ++ ) {
//System.out.print("X"+i+"t");
consola+="X"+i+"t";
}
// System.out.print("error");
consola+="errorn";
//System.out.print("n");
for ( int i =0 ; i< tam ; i ++ ) {
x[i]=1;
//System.out.print(x[i]+"t");
consola+=x[i]+"t";
} consola+="n";//System.out.print("n");
// double tolerancia=0.0001;
double error=tolerancia+ 1;
//int decimales=4;
String funcion="";
EvaluadorFunciones EF= new EvaluadorFunciones();
for ( int i =0 ; i< tam ; i ++ ) {
funcion+="("+resultados[i];
for ( int j =0 ; j< tam ; j ++ ) {if(j!=i)funcion += "-("+
arreglo[i][j]+"*"+x[j]+")"; }
funcion +=")/"+arreglo[i][i];
107. error=x[i];
xn[i]= R.redondear((EF.eval(funcion)),decimales);
error=R.redondear(Math.abs(error-xn[i]),decimales);
//System.out.print(x[i]+"t");
consola+=xn[i]+"t";
funcion="";
}
for ( int i =0 ; i< tam ; i ++ ) {x[i]=xn[i];}
//System.out.print(R.redondear(error,decimales)+"n");
consola+=R.redondear(error,decimales)+"n";
while (error>tolerancia){
for ( int i =0 ; i< tam ; i ++ ) {
funcion+="("+resultados[i];
for ( int j =0 ; j< tam ; j ++ ) {if(j!=i)funcion += "-("+
arreglo[i][j]+"*"+x[j]+")"; }
funcion +=")/"+arreglo[i][i];
error=x[i];
xn[i]= R.redondear((EF.eval(funcion)),decimales);
error=Math.abs(error-xn[i]);
//System.out.print(x[i]+"t");
consola+=xn[i]+"t";
funcion="";
}
for ( int i =0 ; i< tam ; i ++ ) {x[i]=xn[i];}
// System.out.print(R.redondear(error,decimales)+"n");
consola+=R.redondear(error,decimales)+"n";
108. }
return consola;
}
// public static void main(String []args) {
// Jacobi J = new Jacobi () ;
// double arreglo[][] = new double [3][3];
// arreglo[0][0]=8.0;
// arreglo[0][1]=2.0;
// arreglo[0][2]=3.0;
// arreglo[1][0]=1.0;
// arreglo[1][1]=-9.0;
// arreglo[1][2]=2.0;
// arreglo[2][0]=2.0;
// arreglo[2][1]=3.0;
// arreglo[2][2]=6.0;
// double resultados[] = new double [3];
// resultados[0]= 30;
// resultados[1]= 1;
// resultados[2] = 31;
// double x [] = new double [3];
// for ( int i =0 ; i< 3 ; i ++ ) {
109. // x[i]=1;
// }
// System.out.println(J.metodoJacobi(arreglo,resultados,x,0.0001,4));
// }
}
Pruebas
Se procederá a resolver el siguiente sistema de ecuaciones
Los valores iniciales serán [1,1,1]
110. Los resultados son -0.99998 -5.00003 5.00002
Que al ser redondeados serían aproximadamente -1, -5 y 5
Se puede comprobar el sistema cambiando x por los valores obtenidos
12 (-1) -(-5) +3(5)
-12 +5 +15 =-
12+20=8
(-1) +7(-5) -3(5)
-1 -35 -15 =-51
4(-1) -4(-5) +9(5)
-4 +20 +45 =-
4+65=61
Método de Gauss- Seidel
La secuencia de pasos que constituyen el método de Gauss-Seidel es la siguiente:
1. Asignar un valor inicial a cada incógnita que aparezca en el conjunto. Si es posible
hacer una hipótesis razonable de éstos valores, hacerla. Si no, se pueden asignar
valores seleccionados arbitrariamente. Los valores iniciales utilizados no afectarán la
convergencia como tal, pero afectarán el número de iteraciones requeridas para dicha
convergencia.
2. Partiendo de la primera ecuación, determinar un nuevo valor para la incógnita que
tiene el coeficiente más grande en esa ecuación, utilizando para las otras incógnitas
los valores supuestos.
3. Pasar a la segunda ecuación y determinar en ella el valor de la incógnita que tiene el
coeficiente más grande en esa ecuación, utilizando el valor calculado para la incógnita
del paso 2 y los valores supuestos para las incógnitas restantes.
4. Continuar con las ecuaciones restantes, determinando siempre el valor calculado de
la incógnita que tiene el coeficniente más grande en cada ecuación particular, y
utilizando siempre los últimos valores calculados para las otras incógnitas de la
ecuación. (Durante la primera iteración, se deben utilizar los valores supuestos para
las incógnitas hasta que se obtenga un valor calculado). Cuando la ecuación final ha
111. sido resuelta, proporcionando un valor para la única incógnita, se dice que se ha
completado una iteración.
5. Continuar iterando hasta que el valor de cada incógnita, determinado en una iteración
particular, difiera del valor obtenido en la iteración previa, en una cantidad menor que
cierto seleccionado arbitrariamente. El procedimiento queda entonces completo.
Refiriéndonos al paso 5, mientras menor sea la magnitud del seleccionado, mayor será la
precisión de la solución. Sin embargo, la magnitud del epsilon no especifica el error que
puede existir en los valores obtenidos para las incógnitas, ya que ésta es una función de la
velocidad de convergencia. Mientras mayor sea la velocidad de convergencia, mayor será la
precisión obtenida en los valores de las incógnitas para un dado.
Diseño
Diagrama de flujo
122. }
for(int i =0; i<tamanio; i++){
for(int j = 0; j<tamanio; j++){
panelNumeros.add(celdas[i][j]);
}
panelNumeros.add(resultados[i]);
}
panelNumeros.setVisible(false);
panelEncabezado.setVisible(false);
panelIniciales.setVisible(false);
panelNumeros.setVisible(true);
panelEncabezado.setVisible(true);
panelIniciales.setVisible(true);
}
}
public JPanel interfazGaussSeidel() {
return contenido;
}
// public static void main (String [] args){
// Matriz c = new Matriz();
// }
}
123. Clase que implementa el método
public class GaussSeidel{
public String metodoGaussSeidel
(double[][]arreglo,double[]resultados,double[]x,double tolerancia,int decimales) {
String consola="";
int tam= resultados.length;
EvaluarX EX=new EvaluarX();
Redondeo R= new Redondeo();
for ( int i =0 ; i< tam ; i ++ ) {
//System.out.print("X"+i+"t");
consola+="X"+i+"t";
}
// System.out.print("error");
consola+="errorn";
//System.out.print("n");
for ( int i =0 ; i< tam ; i ++ ) {
x[i]=1;
//System.out.print(x[i]+"t");
consola+=x[i]+"t";
} consola+="n";//System.out.print("n");
// double tolerancia=0.0001;
double error=tolerancia+ 1;
//int decimales=4;
String funcion="";
124. EvaluadorFunciones EF= new EvaluadorFunciones();
for ( int i =0 ; i< tam ; i ++ ) {
funcion+="("+resultados[i];
for ( int j =0 ; j< tam ; j ++ ) {if(j!=i)funcion += "-("+ arreglo[i][j]+"*"+x[j]+")";
}
funcion +=")/"+arreglo[i][i];
error=x[i];
x[i]= R.redondear((EF.eval(funcion)),decimales);
error=R.redondear(Math.abs(error-x[i]),decimales);
//System.out.print(x[i]+"t");
consola+=x[i]+"t";
funcion="";
}
//System.out.print(R.redondear(error,decimales)+"n");
consola+=R.redondear(error,decimales)+"n";
while (error>tolerancia){
for ( int i =0 ; i< tam ; i ++ ) {
funcion+="("+resultados[i];
for ( int j =0 ; j< tam ; j ++ ) {if(j!=i)funcion += "-("+
arreglo[i][j]+"*"+x[j]+")"; }
funcion +=")/"+arreglo[i][i];
error=x[i];
x[i]= R.redondear((EF.eval(funcion)),decimales);
error=Math.abs(error-x[i]);
126. double x [] = new double [3];
for ( int i =0 ; i< 3 ; i ++ ) {
x[i]=1;
}
System.out.println(J.metodoGaussSeidel(arreglo,resultados,x,0.0001,4));
}
}
Pruebas
Se usó el siguiente sistema de ecuaciones para probar el programa
Los valores iniciales para x1,x2 y x3 son 1,1,1
127. Los valores obtenidos son 1.99975 3.00009 4.00006
Que al ser redondeados serían 2,3 y 4.
Sustituyendo estos valores en el sistema se comprueba que el resultado es correcto.
6(2) +2(3) +(4)
12 +6 +4 =22
-(2) +8(3) +2(4)
-2 +24 +8 =-
2+32=30
(2) -(3) +6(4)
2 -3 +24 =-
3+26=23
128. Integración y derivaciónnumérica
INTEGRACIÓN NUMÉRICA
Dentrodel CálculoNumérico,laIntegraciónNuméricacomprende una ampliafamiliade
algoritmosparael cálculodel valornuméricode unaintegral definida.Enlamayoría de loscasos,
ese valornuméricoesunvaloraproximadode laintegral definida.
Método del trapecio
Análisis
Para aproximar la solución de una integral definida se puede utilizar la siguiente estrategia;
como la integral definida representa el área bajo la curva, entonces es posible aproximar
dicha área a través de un trapecio (n = 1), ver la figura,
por lo que, una aproximación a la integral definida estará dada por,
Donde la expresión del lado derecho es la formula para el área del trapecio. Sin embargo es
posible mejorar esta aproximación tomando dos trapecios (n = 2), y para ello se divide el
intervalo de integración [a, b], a la mitad para tener, , ver la figura,
129. Así, que la nueva aproximación a la integral definida será,