Introducción a los Métodos

Numéricos
Los métodos numéricos constituyen un conjunto de técnicas y algoritmos, que
permiten resolver planteamientos matemáticos mediante una secuencia de
operaciones aritméticas simples. Una buena parte de dichos métodos están
sustentados por teoremas matemáticos, pero existen algunos donde no es así.
Si bien los métodos numéricos permiten resolver problemas de alta complejidad,
todos ellos requieren un elevado número de cálculos aritméticos. Por tal razón no
fueron muy utilizados hasta la aparición de las computadoras, a pesar de que muchos
métodos eran conocidos desde siglos antes.

El desarrollo conjunto de las computadoras y los lenguajes de programación

propiciaron el desarrollo acelerado de los métodos numéricos, lo cual significó el paso
definitivo a la ingeniería moderna.
Actividad para el estudiante

Buscar y leer artículos o videos sobre el desarrollo de las primeras computadoras

(hasta 1953). Palabras clave:
• Máquina analítica de Charles Babbage
• Calculadora automática de Otto Steiger
• Máquina de Turing
• Computadoras de Konrad Zuse (serie Z)
• IBM Mark I de Howard Aiken
• Máquinas Colossus y ENIAC
• Computadora EDVAC de John von Newmann
La ingeniería antes de las
computadoras
Antes de la aparición de las computadoras, los cálculos aritméticos debían realizarse
de manera manual, apoyándose en tablas matemáticas, las leyes de los logaritmos y
las reglas de cálculo.
Los cálculos aritméticos se realizaban manualmente, apoyándose en tablas
matemáticas, las leyes de los logaritmos y las reglas de cálculo.

Videos ilustrativos sobre el uso de las reglas de cálculo:

https://youtu.be/eif6yEuSbx4?t=111
https://www.youtube.com/watch?v=RCUgT_oMd44
https://www.youtube.com/watch?v=8b2ON8BHelo
También se empleaban las calculadoras mecánicas

Videos ilustrativos sobre el uso de las calculadoras mecánicas:

https://www.youtube.com/watch?v=Smaf8PP75sw
https://www.youtube.com/watch?v=HobzZivjgq0
https://www.youtube.com/watch?v=vjnN6QPiVZE
Muchos hitos de la ingeniería y tecnología se desarrollaron antes de la aparición de las
computadoras modernas, entre ellos:
• Estructuras complejas de acero y concreto
• Rascacielos y puentes de gran claro
• Motores de combustión interna
• Locomotoras, automóviles y aviones
• Turbinas y generadores eléctricos
• Motores a reacción para los primeros jets
• Aeronaves espaciales y satélites
• Bombas y reactores nucleares
En proyectos complejos, era necesario emplear una gran cantidad de calculadoras
humanas, quienes se dedicaban todo el día a realizar cálculos aritméticos “a mano”.

Artículos de interés:
https://www.gacetaeronautica.com/gaceta/wp-101/?p=40018
https://www.bbc.com/mundo/vert-fut-45840951
Computadoras electrónicas
binarias
Circuitos electrónicos

En las computadoras actuales, uno de los componentes esenciales es el circuito lógico

programable. Mediante una disposición compleja de transistores más otros
componentes electrónicos, es posible obtener circuitos con una serie de compuertas
de entrada y salida.
Válvulas, diodos y transistores
Circuito lógico
Circuito lógico estático

0
1
0
1
1
1
0
1 1
1 1
0 1
0 0
1 1
0 0
1 1
1 1
1 1

INPUTS
0 0
1 1
1 0
0 1
1 0
0 1
1 0
1 1
0 0
0 0
0 1
1 0
1 0
0 1
1 0
1
0
1
1
1
0
0
1
1
Circuito lógico programable

0
1
0
1
1
1
0
1 1
1 1
0 1
0 0
1 1
0 0
1 1
1 1
1 1

INPUTS
0 0

OUTPUT
1 1
1 0
0 1
1 0
0 1
1 0
1 1
0 0
0 0
0 1
1 0
1 0
0 1
1 0
1
0
1
1
1
0
0
1
1

1 1 1 0 0 1 1 0 1 0 1 1 1 0 1 0 1 0 1 0 1 0 1 0

INSTRUCTION
Si bien las computadoras son máquinas complejas con muchos componentes, es
convención reconocer los siguientes como los más importantes y costosos

• Procesador o CPU

• Memoria RAM

• Disco de almacenamiento principal (HDD)

• Tarjeta gráfica (GPU)

A ellos sumamos los demás dispositivos necesarios, como la pantalla y el teclado

Arquitectura de Von Newmann

Las computadoras actuales se basan en este modelo, en el cual figuran sus

componentes principales
Dado que las computadoras sólo entienden el sistema binario, es necesario contar con
un “lenguaje de intercambio” que permita a los humanos interactuar con ellas.

Datos:

• Para números enteros simplemente se realiza la conversión del sistema binario al

sistema decimal.

• Para números reales (y complejos), se emplea la representación de punto flotante.

• Para la representación de texto, se requiere realizar un mapeo que relacione una

cadena binaria de longitud fija, con los caracteres utilizados en los principales
idiomas. La primera convención ampliamente aceptada de dicho mapeo se
denominó código ASCII.
En las computadoras, los datos se representan mediante cadenas de dígitos binarios,
mejor conocidos como bits. Cuantos más bits contenga la cadena, mayor es el número
de combinaciones posibles, por lo que puede representar más números enteros o bien
caracteres.

0 1 dígito binario, 2 combinaciones posibles

0 1 2 dígitos binarios, 4 combinaciones posibles

0 1 1 0 4 dígitos binarios, 16 combinaciones posibles

El número total de combinaciones es 2n, donde n es el número de bits que contiene la

cadena.

En el código ASCII se emplean cadenas de 8 bits, pudiendo representar 256 caracteres

diferentes. Esto dio origen a la unidad de medida aún utilizada hasta nuestros días,
denominada byte, y al tipo de dato básico para texto utilizado en los lenguajes de
programación (tipo char en C/C++)
8 bits = 1 byte
Listado completo de símbolos ASCII

Fuentes:
https://elcodigoascii.com.ar/
https://es.wikipedia.org/wiki/ASCII
Para representar números enteros, el rango depende de la longitud de la cadena
binaria. Para la representación del signo se emplea el bit más a la izquierda de la
cadena.

1 1 1 0 1 0 0 1 0 1 0 1 0 1 0 0 = -5451

2 bytes, 16bits, 65536 combinaciones. Tipos short int y unsigned short int. Rango soportado: -32768 a 32767 (0 a 65535 sin
signo).

0 1 0 1 0 1 1 0 1 1 1 0 0 1 0 1 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 = 8693610

4 bytes, 32bits, 4294967296 combinaciones. Tipos int y unsigned int. Rango soportado: -2147483648 a 2147483647 (0 a
4294967295 sin signo).

Nota: Existen enteros con más bytes, pero no son compatibles entre todos los lenguajes y sistemas operativos.
En el caso de los números con cantidades decimales, se emplea la representación de
punto flotante, que consiste en dividir la cadena de bits en dos partes para
representar el número mediante una combinación de dos cantidades enteras. Se
asemeja a la notación científica, y permite representar cantidades de órdenes de
magnitud muy amplia de una manera muy compacta y eficiente.

=0
±𝑎 × 10±𝑏 Donde 𝑎 → se le llama mantisa o significante, siendo un
1 ≤ 𝑎 < 10
número con el punto decimal en posición fija, y b es un exponente entero.

Ejemplos:
2.99792458e8
-1.33247958e-10

0 1 0 1 0 1 1 0 1 0 1 0 0 1 0 1 0 1 0 1 0 1 1 0 1 0 1 0 0 1 0 1

Signo Exponente Mantisa

Debido a que la mantisa tiene el punto decimal en una posición fija, es posible
representarlo mediante un número entero.
Tipos de datos estándar de punto flotante:

0 1 0 1 0 1 1 0 1 0 1 0 0 1 0 1 0 1 0 1 0 1 1 0 1 0 1 0 0 1 0 1

4 bytes: 1 bit para signo, 8 bits en exponente y 23 bits en la mantisa (tipo float o single), 10 cifras significativas de precisión. Rango
soportado: -1.701411733e±38 a 3.402823466e±38 .

0 1 0 1 0 1 1 0 1 1 1 0 0 1 0 1 0 0 1 0 0 0 0 0 1 1 1 0 0 1 1 1 0 1 0 1 0 1 1 0 1 1 1 0 0 1 0 1 0 0 1 0 0 0 0 0 1 1 1 0 0 1 1 1

8 bytes: 1 bit para signo, 11 bits en exponente y 52 bits en la mantisa (tipo double), 16 cifras significativas de precisión. Rango
soportado: -2.2250738585072014e±308, 1.7976931348623158e±308.

Nota: Existen tipos de datos populares de punto flotante con más bytes (long double), pero no son compatibles
entre todos los lenguajes y sistemas operativos. El estándar actual utilizado es el IEEE 754.

Fuente:
https://es.wikipedia.org/wiki/Coma_flotante
https://es.wikipedia.org/wiki/IEEE_754
Para las instrucciones existe el lenguaje ensamblador, y que es el lenguaje de
programación de más bajo nivel en la actualidad. Antes de ingresar al circuito
programable, las instrucciones deben traducirse a lenguaje máquina, el cual consiste
de cadenas binarias de instrucciones y que son específicas a la arquitectura del
circuito.
Normalmente los programas están escritos en un lenguaje de nivel más alto que el
ensamblador, por lo que el proceso de traducción del código fuente a lenguaje
máquina pasa por varias etapas de compilación y ensamblado.

Ver explicación en la siguiente liga:

https://www.thebitdeveloper.com/2015/06/11/sistemas-operativos-maquina-multinivel/
En la actualidad, para el desarrollo de software existen dos tipos de lenguajes de
programación, existiendo los lenguajes compilados de nivel medio (Fortran, C/C++,
Basic), y los lenguajes interpretados (Java, Python, Matlab/Octave, R, VisualBasic,
Julia).

Nota:
Los lenguajes interpretados son al menos 10 veces más lentos que los lenguajes compilados.
Conceptos importantes de
computación
 En las primeras computadoras funcionales, la entrada de datos y el almacenamiento
de la información se realizaba por medio de tarjetas perforadas. Posteriormente, se
añadieron los teclados, y el almacenamiento de la información se realizó mediante
cintas magnéticas, que evolucionaron en los discos magnéticos giratorios (flexibles o
disquetes, y rígidos o duros). Finalmente, aparecieron los discos ópticos y los discos
en estado sólido.

Fuentes:
https://es.wikipedia.org/wiki/Tarjeta_perforada
https://es.wikipedia.org/wiki/Cinta_magnética
https://es.wikipedia.org/wiki/Disquete
https://es.wikipedia.org/wiki/Unidad_de_disco_duro
https://es.wikipedia.org/wiki/Disco_óptico
https://es.wikipedia.org/wiki/Unidad_de_estado_sólido
El volumen de datos en las computadoras se mide en bytes y en unidades derivadas
de ella. Se emplea para medir el espacio de almacenamiento en los dispositivos
permanentes, en las memorias RAM, en el ancho de bus de datos, etc.

• 1 kilobyte (kB) equivale a 1024 bytes

• 1 megabyte (MB) equivale a 1024kB, o 10242 bytes (1048576)

• 1 gigabyte (GB) equivale a 1024MB, o 10243 bytes (1073741824)

• 1 terabyte (TB) equivale a 1024GB, o 10244 bytes (1099511627776)

• 1 petabyte (PB) equivale a 1024TB

Algoritmos
Un algoritmo es un conjunto de instrucciones o reglas definidas y no-ambiguas,
ordenadas y finitas que permite realizar ciertas tareas o actividades: desde procesar
datos y realizar cálculos, hasta tomar decisiones y resolver problemas.​ Dados un
estado inicial y una entrada, se sigue una secuencia de pasos hasta que se llega a un
estado final. En términos de programación, un algoritmo es una secuencia de pasos
lógicos que permiten solucionar un problema específico.

Una forma muy popular para representarlos es el diagrama de flujo.

https://es.wikipedia.org/wiki/Algoritmo
En el ámbito de la computación, la manera más usual es el pseudocódigo.

La implementación de un algoritmo se puede entender como el ensamble físico de

sus componentes de manera que se pueda ejecutar. En el ámbito de la computación,
la implementación es propiamente la escritura del código en un lenguaje de
programación, así como su traducción a lenguaje máquina (ya sea compilado, o
interpretado).
Complejidad algorítmica y costo
computacional
• La complejidad de un algoritmo se puede entender como la cantidad total de
operaciones (o pasos) que necesita para completar totalmente la tarea para la que
fue diseñado. Es una medida directa del tiempo de ejecución, y es independiente
de la máquina que lo ejecuta, del lenguaje y el compilador utilizado en su
implementación, así como del tamaño del problema a resolver.

• El costo computacional es una medida del tiempo de ejecución y los recursos

físicos necesarios para resolver un problema en particular. Depende de la
complejidad del algoritmo utilizado y del tamaño del problema a resolver.

• La eficiencia de un algoritmo está en función de la complejidad y los recursos

físicos que necesita para realizar su tarea. Entre menos tiempo y recursos requiera
un algoritmo, será más eficiente.
En la evaluación de la complejidad del algoritmo, y por tanto de la eficiencia del
mismo y el costo computacional al resolver un problema en particular, se toman en
cuenta tres escenarios:

• Caso peor
• Caso mejor
• Caso promedio

Debido a que el tiempo de cómputo depende directamente de la cantidad de datos a

procesar, de la implementación y de la máquina que lo ejecuta, es preferible
expresarlo en función de la complejidad, por lo que se expresará como T(n).
Ejemplo
Búsqueda de un elemento en una lista

i x
1 0.73935819
2 0.66719802 Caso mejor: 1 (al principio de la lista)
3 0.40056491
4 0.53262758
5 0.25520738
6 0.42512511
7 0.74879519 Caso peor: n (al final de la lista)
8 0.69212476
9 0.5714221
10 0.13658732
11 0.39810212
12 0.87865134 Caso promedio: (n+1)/2
13 0.21061698
14 0.73027072
15 0.7991441
16 0.53835923
17 0.61606979
18 0.40128178
19 0.98090738
20 0.44070134
Si la lista está ordenada, podemos realizar una búsqueda binaria.

i x
1 0.13658732
2 0.21061698
3 0.25520738
4 0.39810212 Caso mejor: 1 (a la primera partición)
5 0.40056491
6 0.40128178
7 0.42512511
8 0.44070134
9 0.53262758 Caso peor: 4 (última partición). Que se puede escribir
10 0.53835923
11 0.5714221
como log2(n)
12 0.61606979
13 0.66719802
14 0.69212476
15 0.73027072
16 0.73935819 Caso promedio: (log2(n)+1)/2
17 0.74879519
18 0.7991441
19 0.87865134
20 0.98090738
Ejercicios
i x i y
1 0.18523935 1 0.8343642
• Suma de dos vectores 2 0.78454766 2 0.8473527
3 0.38118323 3 0.88533281
4 0.75290174 4 0.89576505
5 0.22429491 5 0.94805955
6 0.70781083 6 0.13152811
7 0.78771754 7 0.17719501

• Producto punto de dos vectores 8

9
0.12147799
0.34660518
8
9
0.75625412
0.75253191
10 0.84721266 10 0.85882023

• Suma de dos matrices cuadradas

5.823 5.138 5.884 7.755 1.243 1.657 0.827 7.348
9.428 9.655 7.178 5.592 7.362 3.409 3.466 1.443
7.170 1.241 1.050 2.826 8.636 3.097 4.211 5.952
1.263 6.597 4.903 1.537 1.293 5.865 9.763 4.001

• Producto de dos matrices cuadradas

Al expresar la complejidad de un algoritmo, es muy usual emplear la notación O(n) en
lugar de T(n). La diferencia es que mientras T(n) expresa la complejidad total, O(n)
sólo expresa la complejidad del término más grande de T(n).

Ejemplos:

T(n)=3n+log(n) O(n) = n

T(n)=4n2+10n O(n) = n2

En orden creciente, se tiene la siguiente jerarquía de órdenes de complejidad

1 ≪ log 𝑛 ≪ 𝑛 ≪ 𝑛 ∙ log 𝑛 ≪ 𝑛2 ≪ 𝑛3 ≪ ⋯ ≪ 𝑛𝑝 ≪ ⋯ ≪ 2𝑛 < 𝑚𝑛 ≪ 𝑛!

Polinómicos NP-Duros
NP-Completo
Ejemplo

Determinar la combinación óptima de perfiles de acero para la siguiente estructura,

de manera que resista todas las cargas que actúan sobre ella y que tenga el peso
mínimo.
Para la viga: 102 valores posibles
Para las columnas: 58 valores posibles
Ejemplo

Total de combinaciones posibles: 102x58= 5916

¿Cuántas combinaciones posibles habrá en esta estructura?
Fórmulas útiles para evaluación de la complejidad

• Suma de enteros del 1 a n

𝑛
𝑛(𝑛 + 1) 𝑛2 + 𝑛
𝑖= =
2 2
𝑖=1

• Suma de números pares de 1 a 2n

𝑛 𝑛

2∗𝑖 =2 𝑖 = 𝑛(𝑛 + 1) = 𝑛2 + 𝑛
𝑖=1 𝑖=1

• Suma de números impares de 1 a 2n-1

𝑛 𝑛 𝑛

(2 ∗ 𝑖 − 1) = 2 𝑖− 1 = 𝑛2 + 𝑛 − 𝑛 = 𝑛2
𝑖=1 𝑖=1 𝑖=1

• Suma de los cuadrados de 1 a n2.

𝑛
2
𝑛(𝑛 + 1)(2𝑛 + 1) 2𝑛3 + 3𝑛2 + 𝑛
𝑖 = =
6 6
𝑖=1