_{Imagen editada con GIMP, gráficos hechos con GNU Octave. Elaborada por @abdulmath.}

Saludos queridos lectores, bienvenidos nuevamente a mi Blog. En esta oportunidad les hablaré un poco acerca de Interpolación Polinomial a Trozos usando el entorno GNU Octave | 1^era Parte, el mismo es la continuación de un tema que recientemente desarrollé, Interpolación Polinomial usando el entorno GNU Octave | 1^era, 2^da, y 3^era Parte. La misma está dirigida al público en general (aunque debemos acotar, este es un tema de un nivel más alto, para el que es necesario tener de algunos conocimientos previos de análisis real, cálculo avanzado, entre otros más), con atención especial a profesionales y estudiantes universitarios en ciencias, ingeniería y carreras afines. Estoy abierto a sus comentarios y dudas que puedan surgir en el desarrollo del mismo. Sin perder más tiempo, iniciemos.
https://cdn.steemitimages.com/DQmaTz241KQheijV5qjopsqAzLW8ZpBqCmKmjpaixyGV4Wz/STEMESPANOL06.png
Uno de los puntos importantes que nos dejo como aprendizaje cuando estudiamos el tema de Interpolación Polinomial (1^era, 2^da, y 3^era Parte) es que se debemos evitar interpolaciones polinomiales de alto orden en puntos igualmente espaciados. Esto puede suponer un problema si queremos producir un interpolador preciso en un intervalo grande [a, b]. Una forma de evitar esta dificultad es dividir el intervalo [a, b], https://cdn.steemitimages.com/DQmWe2d58YHuyJxJ4gunW4jTp6Ex9bkrdu36gmdJv2TGTf6/equation00.png y posteriormente interpolamos la función dada en cada subintervalo de la forma [x_i, x_i+1] con un polinomio de orden bajo. Esta es la idea de interpolación polinómica a trozos. A los puntos x_i se le llaman puntos de corte. Iniciaremos estudiando la interpolación lineal a trozos, usando puntos de corte fijos y determinados por adaptación. Como las funciones lineales a trozos no tienen una primera derivada continua, y esto crea problemas en ciertas aplicaciones. Los interpolantes de Hermite cúbicos a trozos abordan este problema. En esta configuración, el valor del interpolador y su derivada se especifica en cada punto de corte. Los interpolantes cubículos locales se unen de una manera que fuerza la continuidad de la primera derivada. La continuidad de la segunda derivada se puede obtener mediante una selección cuidadosa de los valores de la primera derivada en los puntos de corte. Así, entramos en el tema de los splines, la cual es una idea muy importante en el área de aproximación e interpolación. Resulta que las splines cúbicos producen una solución más suave para el problema de interpolación.
https://cdn.steemitimages.com/DQmYbFzjuLoEbkkjqYWcAspTwV91W78juSJBaECfYaAd5a4/STEM-0.png

Interpolación Lineal a Trozos
Supongamos que x(1: n) e y(1: n) son valores dados donde a = x₁ < x₂ < . . .< x_n = b y y_i = f(x_i), con i = 1: n. Si conectamos los puntos (x₁, y₁), . . . , (x_n, y_n) con líneas rectas, como mostramos en la figura siguiente es la gráfica de una función lineal por partes. https://cdn.steemitimages.com/DQmTKAARs26Tgc4PrkmYCEKNsKVSkg2QqiHyDN2hYey8vEt/Piecese01.png _{Función lineal a trozos, elaboada en GNU Octave, por @abdulmath.} El interpolador lineal a trozos se basa en los interpolantes lineales locales siguientes https://cdn.steemitimages.com/DQmYZriufQRsManMoGxfwbGdEhUYLvtT5YY6gKu517S3L9S/equation01.png donde para i = 1: (n-1) los coeficientes están definido por https://cdn.steemitimages.com/DQmeHY3k2DT615UPHtN8ELM95uWLhXH272L77TyrKRe5kEf/equation02.png Notemos que L_i(z) es simplemente el interpolador lineal de f en los puntos x = x_i y x = x_{i + 1}. Definamos https://cdn.steemitimages.com/DQmX1ThP25hyzNuHZmbYYGRxKsGyDhEhthR4pa86S7Mv9tg/equation03.png El hecho de configurar L es el hecho de resolver cada uno de los problemas de interpolación lineal local. Las n - 1 diferencias divididas B₁, B₂, . . . , B_{n - 1} puede ser fácilmente calculadas por un bucle de la forma siguiente https://cdn.steemitimages.com/DQmNvx6HM5vQMqZvAspW3sFfvScHreq3VhZs2qeBnuUcZVM/equation04.png o mediante el uso de división puntual, https://cdn.steemitimages.com/DQmU9Qvjx3NFHQmEwo6R1acZKCwUWSXr2Yamtc7tXvEnzyw/equation05.png o usando la función ```diff``` de la forma siguiente: https://cdn.steemitimages.com/DQmZDoNaeEX5wqrkcMupaXQ5PGsfzYkda8xAvf7gXsqCcnL/equation06.png Usando algunas de estas operaciones podemos construir la siguiente función https://cdn.steemitimages.com/DQmQMusEonTmczQcp1iLGCLvRcBj3pHE8UfJv1aox86uX1F/equation07.png _{Script de una Función de interpolación lineal a trozos, elaborada en GNU Octave, por @abdulmath.} Así, el siguiente script https://cdn.steemitimages.com/DQmagQ7dxMr16jYoNqpKowRzWW2z42zZuRA8rXYyuPj2FXB/equation08.png establece un interpolador lineal por partes de la función https://cdn.steemitimages.com/DQmZeDXRLraQaiF2fHFGj2H1cpDvdJ1q9XAzMWpCYDxYTZo/equation09.png en una partición uniforme de 15 puntos del intervalo [0,1]. La gráfica la podemos ver a continuación. https://cdn.steemitimages.com/DQmYqv77eAnezuM8qtJq86Kxota5iciqBkM1wPAYCj7fEKF/Piecese02.png _{Elaborada con GNU Octave, por @abdulmath.}
https://cdn.steemitimages.com/DQmWXaTLF4uGH9x4QgPh29vKFUfyTGrzPaN2v4zytNiEEzC/SeparadorGMath33.png

Evaluación
Para evaluar L en un punto z del intervalo [a, b], es necesario determinar el subintervalo que contiene z. En nuestro problema x tiene la propiedad de que x₁ < . . . < x_n y por lo tanto ```sum(x <= z)``` es el número de x_i que están a la izquierda de z o igual a z. Resulta que https://cdn.steemitimages.com/DQmVE6PiUcsWTU493AkKTPL5qjQxFXH7dE5kBZJBeqcec7c/equation10.png determina el índice i de modo que https://cdn.steemitimages.com/DQmUtbMWZuaUvp83QmeXSL7y6tMgZc4q7WZ21Jo4iuP272N/equation11.png Observe el manejo especial del caso cuando z es igual a x_n. Se realizarán un total de n comparaciones porque cada componente en x se compara con z. Un mejor enfoque es explotar la monotonía de x_i y usar la búsqueda binaria. Está es la idea principal. Supongamos que tenemos índices ```Izq``` y ```Der``` tal que https://cdn.steemitimages.com/DQmQB6GsR4pkLLWLQgp5cXNzndB9pBCiHVwcgVgVM1yozgk/equation12.png Si ```medio=floor((Izq + Der)/2)``` entonces para chequear z con la relación x_medio podemos reducir a la mitad el espacio de búsqueda redefiniendo ```Izq``` o```Der``` por lo tanto: https://cdn.steemitimages.com/DQmNf1szG5L7Q5Dfo234ATxRqKYwDjiuAxWfMHrGws5M4VR/equation13.png La aplicación repetida de este proceso finalmente identifica el subintervalo que contiene a z: https://cdn.steemitimages.com/DQmVaYS9JurzVEf1TY1F95brzSXabgAhqfvntbSfb8X421L/equation14.png _{Script para determinar el índice i para localizar z. Elaborado en GNU Octave, por @abdulmath.} Al finalizar, i indica el índice del subintervalo que contiene a z. Si n = 10 y z pertenece al intervalo [x₆, x₇], entonces aquí está la sucesión de valores ```Izq``` y ```Der``` producidos por el método de búsqueda binario: |```Izq```|```Der```|```medio```| |---|---|---| |1|10|5| |5|10|7| |5|7|6| |6|7|```-```| Aproximadamente log₂(n) son las comparaciones necesarias para localizar el subintervalo apropiado. Si n es grande, entonces esto es mucho más eficiente que el método de ```sum(xn comparaciones. Para z aleatorio, no podemos hacer nada mejor que la búsqueda binaria. Sin embargo, si se va a evaluar L en una sucesión de puntos anotada, entonces podemos mejorar el proceso de ubicación del subintervalo. Por ejemplo, supongamos que queremos gráficar L en [a, b]. Esto requiere el ensamblaje de los valores L(z₁), . . . , L(z_m) en un vector donde m es un número entero generalmente grande y https://cdn.steemitimages.com/DQmTZXvi9HuxLa5oZRXH4JY4v8uCAw7F2tkM75AZiGDi9mS/equation15.png En lugar de localizar cada z_i mediante búsqueda binaria, es más eficiente explotar la migración sistemática del punto de evaluación a medida que se mueve de izquierda a derecha en los subintervalos. Lo más probable es que si i es el índice del subintervalo asociado con el valor z actual, entonces i será el índice correcto para el siguiente valor z. Esta conjetura de el subintervalo correcto se puede verificar antes de iniciar el proceso de búsqueda binaria. https://cdn.steemitimages.com/DQmSxTZBs1xwUVRwcAsqViXNjrM29zDMuD2XUVhjhhaj858/equation18.png _{Script de Localización optimizado, elaborado en GNU Octave, por @abdulmath.} La función ```Locate``` hace uso del comando de ```return```. Este termina la ejecución de la función. Es posible reestructurar la función ```Locate``` para evitar ```return``` pero la lógica resultante sería engorrosa. Como una aplicación de ```Locate``` aquí hay una función que produce un vector de L valores: https://cdn.steemitimages.com/DQmQ8YRLaympNbY6iSsgUmkut7ccjCFWYU6DxKGzYNtcbRB/equation19.png _{Script de función de aplicación. Elaborado en GNU Octave, por @abdulmath.} El siguiente script ilustra el uso de esta función, produciendo una secuencia de aproximaciones lineales a trozos a la función https://cdn.steemitimages.com/DQmYBVA3n6haFpsb4fHfkEUPvZJjAGSES2BySdJVBkkpcdR/equation20.png _{Script de aplicación. Elaborado en GNU Octave, por @abdulmath.} Observe que se requieren más puntos de interpolación en regiones donde las jorobas son particularmente no lineales. https://cdn.steemitimages.com/DQmWh2iFJ5zEM8zYoPwCbDneaU3pcPCob2qMW7uYvi4GtCT/PieceseTwo01.png
https://cdn.steemitimages.com/DQmbzowUTvMjLokDgV95knYkXX9Va7RmdGG6H6RZqNLD3Pp/PieceseTwo02.png _{Gráficas obtenidas de la Aplicación. Elaboradas con GNU Octave, por @abdulmath}
https://cdn.steemitimages.com/DQmWc6PNwWG3TTTx9BQoTy4a8M7nVh88YMQAwVFjX6msEFD/SeparadorStem.png

Determinación a Priori de los Puntos de Cortes
Consideremos cuántos puntos de corte necesitamos para obtener un interpolador lineal por partes satisfactorio. Si z pertenece al intervalo [x_i, x_{i + 1}], tenemos https://cdn.steemitimages.com/DQmTAxfQJF76sbCLG5NFiycbYYBAaguqe8eA2PpbrFWcsz3/equation21.png donde n pertenece al intervalo [x_i, x_{i + 1}]. Si la segunda derivada de f en [a, b] está acotada por M₂ y si h es la longitud del subintervalo más largo de la partición, entonces no es difícil mostrar que https://cdn.steemitimages.com/DQmVEjAa2vrJqphRT8AQtpfqJ1mPXz61e3ciWotdWDaSUeC/equation22.png Una situación típica en la que se puede aprovechar esta cota del error es en el diseño de la partición subyacente en la que se basa L. Suponga que L(x) se basa en la partición uniforme https://cdn.steemitimages.com/DQmWe2d58YHuyJxJ4gunW4jTp6Ex9bkrdu36gmdJv2TGTf6/equation00.png donde https://cdn.steemitimages.com/DQmQpWPt73jJFah8qf73rEN9cnefjY4FYRi2TqJUjDSDoYx/equation23.png Para garantizar que el error entre L y f es menor o igual que una tolerancia positiva dada, insistimos que https://cdn.steemitimages.com/DQmWdtANKUoUwBfn5uoBzbFAvLizFVstygPbo6nY3BMaABJ/equation24.png De esto concluimos que n debe satisfacer https://cdn.steemitimages.com/DQmddfBxexxZ1NEhLXa4ijit2t4J17PqZACFqktU8pwhgo7/equation25.png Por el motivo de la eficiencia, tiene sentido dejar que n sea el número entero más pequeño que satisface la desigualdad. https://cdn.steemitimages.com/DQmUfkdsaxN6bWYfYypX8F1deVn3vu7KLihQx2BjtG6DcjL/equation26.png _{Script para construir la partición.Elaborado con GNU Octave, por @abdulmath} La partición producida por ```pwLStatic``` no tiene en cuenta los valores muestreados de f. Como resultado, la partición uniforme producida puede ser demasiado refinada en regiones donde f'' es mucho más pequeña que la cota M₂.
https://cdn.steemitimages.com/DQmWXaTLF4uGH9x4QgPh29vKFUfyTGrzPaN2v4zytNiEEzC/SeparadorGMath33.png

Interpolación Lineal a Trozos Adaptativa
Supongamos f no es muy lineal en una pequeña parte de [a, b] y es muy suave en otros lugares. (Comó pudimos observar en las gráficas anteriores.) Esto significa que si usamos ```pwLStatic``` para generar la partición, entonces estamos obligados a usar una cota M₂ grande. Se necesitarán muchos subintervalos y f-evaluaciones. Sobre las regiones donde f es suave, la partición será demasiado refinada. Para resolver este problema, desarrollamos un algoritmo de partición recursivo que encuantra dónde f es "no lineal" y eso agrupa los puntos de cortes en consecuencia. Una definición simplifica la discusión. Decimos que el subintervalo [x_L, x_R] es aceptable si https://cdn.steemitimages.com/DQmSz2FxGrWZKFAvv8SqtLhAnYVLCg8E2ygsLnKGezNjwgs/equation27.png o si https://cdn.steemitimages.com/DQmYQA7u6xeuFK7zdggrZM82qZBFjqxfkRdyPq6mCNrtwaS/equation28.png donde delta y h_min son positivos, se les conoce como los parámetros de refinamiento (típicamente pequeños). La primera condición mide la discrepancia entre la línea que conecta (x_L, f(x_L)) y (x_R, f(x_R)) y la función f(x) en el punto medio del intervalo m = (x_L + x_R)/2. La segunda condición dice que los subintervalos suficientemente pequeños también son aceptables cuando suficientemente pequeño significa menos de la longitud hmin. Se requiere una definición más antes de que podamos describir el proceso de partición completo. Una partición x₁ < x₂ < . . . < x_n es aceptable si cada subintervalo es aceptable. Tenga en cuenta que si https://cdn.steemitimages.com/DQmRNxTqXLt7FqSY9EfpBwgXfwfZisVrAmAtfoR6i7sffht/equation29.png es una partición aceptable de [x_L, m], y si https://cdn.steemitimages.com/DQmVZTu9ZfJt8inxNQmP9HR5zunSPkad8VkKUsKYctTf499/equation30.png es una partición aceptable de [m, x_R], entonces https://cdn.steemitimages.com/DQmcmdXQX5uZ9kaf6UFhvNGzeWtA1esvTSxjo7uGshLiVip/equation31.png es una partición aceptable de[x_L, x_R]. Esto establece el escenario para una determinación recursiva de partición aceptable. https://cdn.steemitimages.com/DQmf4y2ZAoPKzRqpCsYA5k1ZUKdq6vz7kJ9KXW8nNY1MYGm/equation34.png _{Función para construcción de la partición recursiva. Elaborado en GNU Octave, por @abdulmath.} La idea detrás de la función es verificar y ver si el intervalo de entrada es aceptable. Si no lo es, las particiones aceptables se obtienen para los intervalos de la mitad izquierda y derecha. Luego se unen para obtener la partición final aceptable. La distinción entre interpolación lineal a trozos estática y adaptativa se revela mediante el siguiente script https://cdn.steemitimages.com/DQmeo3tesDL6Zaok7eT6qapjYC5TzxvLTxaMmBbr6TkHz2z/PieceseTwo03.png
https://cdn.steemitimages.com/DQmc9T282zsAFCNWt5tJuVFVU9Ecrk5GsVuvBvWjmdAefMJ/PieceseTwo04.png
https://cdn.steemitimages.com/DQmQiXVaxUG3xvMteiV6xstX9RDHqcgSPfKG4FBoHd6VY4v/Piecese11.png La función ```humps``` es muy no lineal en las proximidades de x = 0.3. La cota de la segunda derivada se aproxima con diferencias y se usa en ```pwLStatic```. En el ejemplo, aproximadamente dos veces se requieren tantas evaluaciones de funciones cuando se toma el enfoque estático.
https://cdn.steemitimages.com/DQmZne2kvXmUvL8qD6Bsa9iwnX8M6i4NMd8QCQSmNhsnqqb/SeparadorGMath08.png
Queridos amigos y lectores, espero hayan disfrutado y aprendido acerca de la Interpolación Polinomial a Trozos usando el entorno GNU Octave | 1era Parte, de igual manera los invito para la 2da Parte de este tema, donde continuaremos mostrando el desarrollo del mismo con los script y aplicaciones. Espero que esto pueda servir de apoyo a ustedes, hijos, nietos, sobrinos o amigos que quieran aprender un poco más del maravilloso mundo de las matemáticas y la programación. No olviden dejar sus comentarios. Saludos y nos leemos pronto.
Si desean consultar un poco más del tema pueden usar las siguientes referencias: + Demidovich, B. P., and I. A. Maron. Computational Mathematics Mir, Moscow, 1976. + Björck, Åke. Numerical methods in matrix computations. Vol. 59. Cham: Springer, 2015. + Burden, Richard L., and J. Douglas Faires. Numerical analysis. Ninth Edition. Cengage Learning. 2011.
Las imágenes, separadores y las ecuaciones fueron creadas y editadas por @abdulmath usando software libre, GNU Octave, https://cdn.steemitimages.com/DQmYbufK9HG9LpAUVgEcFSNVmZG2irkjVy1duWbYqVyVtf4/LateX.png, GIMP e Inkscape.
https://cdn.steemitimages.com/DQmaTz241KQheijV5qjopsqAzLW8ZpBqCmKmjpaixyGV4Wz/STEMESPANOL06.png
@SteemSTEM es un proyecto comunitario con el objetivo de promover y apoyar la Ciencia, la Tecnología, la Ingeniería y las Matemáticas en la blockchain Steem. @Stem-espanol es parte de esta comunidad, si desea apoyar el proyecto, puedes contribuir con contenido en español en las áreas de Ciencia, Tecnología, Ingeniería y Matemáticas, utilizando las etiquetas #steemstem y #stem-espanol. https://cdn.steemitimages.com/DQmaSVacTwJ8v8uqJLMAKkNaLhisPAx7bi7KXVuzV1B3uQm/FinalGMath00.png _{Imagen diseñada con GIMP y elaborada por @abdulmath.}