Hola a todos.
Como estoy haciendo una aplicación en la que hago un uso intensivo de diversos sistemas de interpolación, se me ocurrió compartir con vosotros la experiencia por si a alguien le resulta útil.
En este tema iré colocando los distintos trozos de código que voy empleando y probando de manera más o menos intensiva.
Empezaré con Lagrange en una sola dimensión —muy fácil, y que también podréis encontrar en miles de páginas de programación—. Luego Lagrange en dos y un par de rutinas para la selección de datos para interpolar —en una, dos y varias dimensiones—.
Newton —ahorro de recursos en determinados casos—, spline y Chevichev - Hermite también los tengo programados, pero aún me sale algún error, con lo cual las pondría más delante.
Empiezo con Lagrange.

El método de Lagrange se puede usar para realizar interpolaciones —y extrapolaciones a riesgo de cada cual— en las siguientes condiciones:

• Que las tablas no sean siempre las mismas, es decir que cambien dentro de la ejecución del programa —para tablas siempre iguales están, p.e. spline—
  
• Que los intervalos en las «X» no sean iguales —para el caso contrario está diferencias finitas, que ahorra tiempos—.
  
• Que la tabla esté ordenada y no contenga valores de «X» repetidos.

El grado del polinomio de interpolación viene dado por el tamaño de la tabla asociada. Los más habituales suelen ser:

• Dos datos: Grado 1 o interpolación lineal.
  
• Cuatro datos: Grado 3 o interpolación cúbica.
  
• Seis datos: Grado 5.

La «X» sobre la que se busca la «Y» debería estar entre los datos centrales, pero no es estrictamente necesario, como ya explicaré con las rutinas de búsqueda de datos.
Adjunto código. Os ruego que comentéis no ya posibles mejoras, que seguro que las hay, sino cualquier idea que se os pase por la cabeza:

Por el criterio de unidad de polinomios de interpolación —que, por supuesto, es aplicable a varias dimensiones—, se puede interpolar en una dirección y luego en otra, y además es irrelevante el orden.
La discusión de la conveniencia del uso y los grados ya están discutidos en Lagrange en una sola dimensión.
Por tanto, el método busca primero un vector de "Y" que se corresponde con las "X", y después, sobre esas "Y" y "Z" obtenidas, interpola las "X". Quizá sea más fácil verlo en el código.

justo lo que necesito, gracias!

Muy bueno. +1

===================
No podemos regresar

Gracias, compañeros, por los comentarios.
En los dos listados que he puesto hasta ahora no hay gestión de errores, lo cual es raro porque, como todos conocéis, el código asociado a este asunto suele ser de un tercio a la mitad del código global. Pero da mucha pereza escribirlo. Tanta, que, insisto, ni siquiera lo he incluido.
Pero hay que gestionarlo; venga, que nos ponemos las pilas y vamos a ello.
Los errores, si hiciésemos de estas funciones algo realmente generalista y de uso en cualquier aplicación, vienen de la parte menos controlada: Los argumentos Variant. Pero también de la propia naturaleza de los datos.

• Los argumentos han de ser vectores (es decir, matrices de una sola dimensión) y del mismo número de datos. Esto es fácil de comprobar con las propiedades Dim y Count. En el caso de dos dimensiones, «X» e «Y» han de ser vectores cuyas longitudes han de coincidir con las dos dimensiones de «Z».
  
• Los argumentos «X» han de estar en orden —en principio es indiferente si ascendente o descendente si el grado es impar—. En bidimensional, tanto «X» como «Y» han de estar ordenados. Comprobar esto ya lleva más tiempo y líneas de código «feo», ya sabéis, bucles en apariencia innecesarios dentro de una función que habrá que llamar en muchos casos varias veces con los mismos datos o parecidos —síííí, para eso están los spline—.
  
• Los valores de «X» han de ser todos distintos para evitar divisiones por cero. Lo mismo que las «Y» en el caso bidimensional. Se puede comprobar con el mismo bucle que antes.

Pero hay otro error de división por cero que es difícil de controlar por lo inesperado. Probad lo siguiente:

  

No es fácil a priori que se den las circunstancias de que la diferencia de las «Y» sea cercana al infinito virtual de Float [-8.98846567431105E+307 ; +8.98846567431105E+307] ni que la diferencia de las «X» esté cercana al cero virtual de Float [2^-52]. Como tampoco es fácil controlar este error si no recurrimos a un pequeño truco:

 


El empleo de valor absoluto dentro de los logaritmos es fundamental, ya que ambas diferencias pueden ser negativas. Sólo quedaría controlar que la diferencia en las «Y» no sea cero porque el control de errores... ¡tachán! daría error.
Y creo que eso es todo. Siento el tocho, pero mi pereza por programar control y gestión de errores me lleva a ser explícito    

      ¡Piedad, que soy de letras!

===================
No podemos regresar

Nos falta por saber el uso que le estás dando al algoritmo. Supongo que es puramente gráfico, pero no sé con qué finalidad. Es decir, ¿podría emplearse para interpolar colores de píxeles, o para determinar zonas en una imagen 2d o quizás en alguna aplicación 3d? ¿Otros usos posibles fuera de lo meramente gráfico?

Muy interesante, en cualquier caso. Gracias por compartir.

Saludos

===================
Jesús Guardón

Por favor, usemos el corrector ortográfico antes de pulsar el botón "Enviar".

"uo ǝs ʇɐu pıɟıɔıן ɐdɹǝupǝɹ ɐ dɹoƃɹɐɯɐɹ, soןo ɥɐʎ bnǝ dɹodouǝɹsǝןo"

Shordi, no me lo creo. Si lo entiendo yo, lo entiende todo el mundo —sí, me reconozco algo límite—   . Off-topic.- Creo que eres escritor. ¿Cómo no te pasas por ociozero a participar en las microjustas? Quizá estás ya con otro alias...  
jguardon: Varias aplicaciones. Por supuesto lo puedes emplear para cualquier necesidad de interpolación que te surja: aplicación gráfica, de sonido, vídeo, cartografía... lo que quieras. He terminado un psicrométrico en excel   para el curro y ahora estoy en gambas3 con el criterio«Torres» para la visibilidad de objetos difusos asociado al catálogo del Saguaro Astronomic Club —por eso estuve hace tiempo pesadito preguntando cosas de bases de datos—. En cuanto esté más visible, prometo colgarlo.

A lo que iba. Normalmente para interpolar se emplean grados impares, especialmente los primeros: lineal, cúbico o grado cinco. ¿Por qué? Porque ... mejor una «retrataura»

 

Interpolamos con segundo grado en torno al cero. Si tomamos los valores de la izquierda, tenemos un uno. Si tomamos de la derecha, un menos uno. Y el valor depende de una decisión nuestra. Por tanto, es mejor escoger un grado impar, porque necesita un número par de puntos, y puedes situar tu punto justo en el intervalo central. No lo he puesto, pero con un ejemplo tan simétrico, con interpolación lineal o cúbica —no hay puntos para más— sale cero. Un comentario: Sea cual fuere el método, para un mismo grado, el polinomio es siempre el mismo. Pero en este caso estamos cambiando los puntos, por lo que el polinomio es distinto según el conjunto de puntos.

Por supuesto, en los extremos de las tablas se pueden y se deben usar grados pares, pero eso lo explicaré luego, que hoy me voy a echar a la siesta un rato.

Prometo no incordiar demasiado más. Pongo uno sobre extremos y extrapolación y otro sobre spline, y ya está. Bueno, lo mismo me da la vena y coloco Hermite - Chevichev.

Citar:

Off-topic.- Creo que eres escritor. ¿Cómo no te pasas por ociozero a participar en las microjustas? Quizá estás ya con otro alias...  

No conocía esa web. Le he estado echando un ojo y creo que no es para mí... demasiado apresurada y "violenta", me temo, que yo soy muy chano-chano.

De todas formas gracias por el enlace. He disfrutado explorándolo un poco.

===================
No podemos regresar