[Tachikomaia]

Interpolación (Ajuste exacto)
Se usa cuando tienes una serie de puntos de datos conocidos y quieres encontrar una función matemática que pase exactamente por encima de todos ellos.

Yo quiero que pueda haber ifs, redondeos, todo lo necesario.

Intento hacer un programa así.

Hasta donde por ahora intenté que funcione, funciona.

Falta:

- Que la solución muestre el valor de cada paso que incluya (por ahora sólo muestra el de un paso).

- Que muestre exacto qué hace cada paso, en vez de mostrar sólo qué número es (con el número hay que fijarse qué hace ese paso ¿sumar? ¿multiplicar? etc).

- Más variedad de valores. Por ahora sólo prueba -1, 0 y 1.

- Que los pasos varíen antes que los valores.

- Más variedad de pasos.

Y probablemente más cosas. Bueno, pregunten/aporten lo que quieran:

Código: [Seleccionar]

Datos = 3;
Dato1 = 1;
BuenResultado1 = 2;
Dato2 = 2;
BuenResultado2 = 3;
Dato3 = 3;
BuenResultado3 = 4;
TiposDePaso = 2;
Pasos = 0;
while (Pasos < 2) {
// Se prueba un método con un paso más, para probar métodos que sólo tienen 1 paso, luego métodos que tienen 2, etc:
Pasos++;
// Crea nuevo paso:
this["PasoaProbar"+Pasos] = 0;
trace("Aumentó la cantidad de pasos, es "+Pasos);
trace("Creado el PasoaProbar"+Pasos+", su valor es "+this["PasoaProbar"+Pasos]);
NroDePasoaVariar = Pasos+1;
// Se indica que el paso a variar sea otro, para que varíe el último hasta que no se pueda, se reseteé, luego el penúltimo, y así, para lograr todas las variaciones posibles:
while (NroDePasoaVariar > 1) {
NroDePasoaVariar--;
trace("Se redujo el NroDePasoaVariar, ahora es "+NroDePasoaVariar);
// Resumen:
PasoaProbar_ = "PasoaProbar"+NroDePasoaVariar;
// Se modifica el paso indicado:
while (this[PasoaProbar_] < TiposDePaso) {
this[PasoaProbar_] = this[PasoaProbar_]+1;
trace("Se varió el paso, ahora su valor es "+this[PasoaProbar_]);
// trace(PasoaProbar1+" y "+PasoaProbar2);
ValoraProbar = -2;
// Se modifica el valor que usará el paso, para que por ejemplo se pruebe +1, +2, etc:
while (ValoraProbar < 1) {
ValoraProbar++;
trace("Se varió el ValoraProbar, ahora es "+ValoraProbar);
BuenResultadoHallado = true;
NroDeDatoaProbar = 0;
// Se modifica qué "Input" se chequea:
while (NroDeDatoaProbar < Datos && BuenResultadoHallado == true) {
NroDeDatoaProbar++;
trace("Se varió el NroDeDatoaProbar, ahora es "+NroDeDatoaProbar);
trace("Su correspondiente buen resultado es "+eval("BuenResultado"+NroDeDatoaProbar));
NroDePasoaEjecutar = 0;
// Se modifica el paso a ejecutar, para ver si el método (fórmula) sirve para lograr el resultado deseado con ese dato de input:
while (NroDePasoaEjecutar < Pasos) {
NroDePasoaEjecutar++;
trace("Se ejecutó el paso "+NroDePasoaEjecutar);
this["TipoDePaso"+this["PasoaProbar"+NroDePasoaEjecutar]]();
// Resultado = this["Resultado"+NroDePasoaEjecutar];
trace("El resultado es "+this["Resultado"+NroDePasoaEjecutar]);
}
if (this["Resultado"+Pasos] != this["BuenResultado"+NroDeDatoaProbar]) {
BuenResultadoHallado = false;
trace("El resultado no es el deseado");
} else {
trace("El resultado es el deseado");
if (NroDeDatoaProbar == 3) {
trace("Solución hallada");
trace("Valor: "+ValoraProbar);
trace("Paso1: "+this["PasoaProbar"+NroDePasoaEjecutar]);
Pasos = 9;
NroDePasoaVariar = 0;
TiposDePaso = 0;
ValoraProbar = 9;
}
}
}
}
}
if (BuenResultadoHallado == false) {
this[PasoaProbar_] = 1;
trace("El paso "+this[PasoaProbar_]+" ya no puede variar, se reseteó ");
}
}
}
function TipoDePaso1 () {
trace("El paso ejecutado fue Dato+Valor");
_root["Resultado"+Pasos] = _root["Dato"+NroDeDatoaProbar]+ValoraProbar;
}
function TipoDePaso2 () {
trace("El paso ejecutado fue Dato*Valor");
_root["Resultado"+Pasos] = _root["Dato"+NroDeDatoaProbar]*ValoraProbar;
}
function TipoDePaso3 () {
trace("El paso ejecutado fue Dato/Valor");
_root["Resultado"+Pasos] = _root["Dato"+NroDeDatoaProbar]/ValoraProbar;
}
function TipoDePaso4 () {
trace("El paso ejecutado fue Valor/Dato");
_root["Resultado"+Pasos] = ValoraProbar/_root["Dato"+NroDeDatoaProbar];
}