¿El programa dice que 9999999+1 es 9999999.99999999?

(1/2) > >>

Tachikomaia:
Quiero un programa que haga esto:
N = 0
N = 1
N = 10
N = 2
N = 101
N = 1000
etc

O sea:
1era vuelta: Se produce un número de 1 cifra.
2nda: De 1 cifra, de 2 cifras.
3era: De 1 cifra, de 2 cifras, de 3 cifras.
Y así sigue.

Cada nuevo número de cierta cifra es +1 con respecto al anterior de esas cifras.

Cuando con 1 cifra no haya más posibles, ya no se producen más de esos, lo mismo ocurre con los de cualquier otra cifra. Es que luego del 9 viene el 10 pero ese tiene 2 cifras, ya se produjo, no quiero que se produzcan repetidos.

Hice este código y le puse traces porque me da un error que no entiendo:
Código
Escena 1
  actions for fotograma 1
     MinLongitud = 1;
     MaxLongitud = 1;
     N1 = -1;
  actions for fotograma 2
     Longitud = MinLongitud;
     trace ("F2: Longitud: "+Longitud);
  actions for fotograma 4
     Nombre = "N"+Longitud;
     trace ("Nombre: "+Nombre);
     N = eval(Nombre)+1;
     trace ("N: "+N);
     if (String(N).length>Longitud) {
        trace (String(N).length+" > "+Longitud);
        // El valor ya fue producido.
        MinLongitud = MinLongitud+1;
        trace ("MinLongitud: "+MinLongitud);
        gotoAndPlay (2);
     } else {
        // Guardar el valor en la lista correspondiente.
        set (Nombre, N);
        trace ("Se generó "+Nombre+": "+N);
        C = String(N).charat(N);
        // trace (N+" resulta "+C);
        if (C == 0) {
           if (Solfor0 == undefined) {
              Solfor0 = N;
           }
        } else if (C == -9) {
           if (Solfor9 == undefined) {
              Solfor9 = N;
           }
        } else if (C == 4.5) {
           if (Solfor4 == undefined) {
              Solfor4 = N;
           }
        } else if (C == -7.2) {
           if (Solfor7 == undefined) {
              Solfor7 = N;
           }
        }
     }
  actions for fotograma 5
     if (Longitud<MaxLongitud) {
        Longitud = Longitud+1;
        gotoAndPlay (4);
     } else {
        // Se creará una nueva lista.
        MaxLongitud = MaxLongitud+1;
        set ("N"+MaxLongitud, -1+Math.pow(10, MaxLongitud-1));
        trace ("Se creó N"+MaxLongitud+": "+String(-1+Math.pow(10, MaxLongitud-1)));
        gotoAndPlay (2);
     }

Salida:
Citar

F2: Longitud: 1
Nombre: N1
N: 0
Se generó N1: 0
Se creó N2: 9
F2: Longitud: 1
Nombre: N1
N: 1
Se generó N1: 1
Nombre: N2
N: 10
Se generó N2: 10
Se creó N3: 99
F2: Longitud: 1
Nombre: N1
N: 2
Se generó N1: 2
Nombre: N2
N: 11
Se generó N2: 11
Nombre: N3
N: 100
Se generó N3: 100
Se creó N4: 999
F2: Longitud: 1
Nombre: N1
N: 3
Se generó N1: 3
Nombre: N2
N: 12
Se generó N2: 12
Nombre: N3
N: 101
Se generó N3: 101
Nombre: N4
N: 1000
Se generó N4: 1000
Se creó N5: 9999
F2: Longitud: 1
Nombre: N1
N: 4
Se generó N1: 4
Nombre: N2
N: 13
Se generó N2: 13
Nombre: N3
N: 102
Se generó N3: 102
Nombre: N4
N: 1001
Se generó N4: 1001
Nombre: N5
N: 10000
Se generó N5: 10000
Se creó N6: 99999
F2: Longitud: 1
Nombre: N1
N: 5
Se generó N1: 5
Nombre: N2
N: 14
Se generó N2: 14
Nombre: N3
N: 103
Se generó N3: 103
Nombre: N4
N: 1002
Se generó N4: 1002
Nombre: N5
N: 10001
Se generó N5: 10001
Nombre: N6
N: 100000
Se generó N6: 100000
Se creó N7: 999999
F2: Longitud: 1
Nombre: N1
N: 6
Se generó N1: 6
Nombre: N2
N: 15
Se generó N2: 15
Nombre: N3
N: 104
Se generó N3: 104
Nombre: N4
N: 1003
Se generó N4: 1003
Nombre: N5
N: 10002
Se generó N5: 10002
Nombre: N6
N: 100001
Se generó N6: 100001
Nombre: N7
N: 1000000
Se generó N7: 1000000
Se creó N8: 9999999
F2: Longitud: 1
Nombre: N1
N: 7
Se generó N1: 7
Nombre: N2
N: 16
Se generó N2: 16
Nombre: N3
N: 105
Se generó N3: 105
Nombre: N4
N: 1004
Se generó N4: 1004
Nombre: N5
N: 10003
Se generó N5: 10003
Nombre: N6
N: 100002
Se generó N6: 100002
Nombre: N7
N: 1000001
Se generó N7: 1000001
Nombre: N8
N: 9999999.99999999
16 > 8
MinLongitud: 2
F2: Longitud: 2
Nombre: N2
N: 17
Se generó N2: 17

O sea, no genera el número 8 ni el 9, porque, si lo interpreté bien, cuando N8 = 9999999 y Longitud = 8, y se hace esto:
Código:

Nombre = "N"+Longitud;
N = eval(Nombre)+1;

El resultado es:
Nombre = "N"+8 = "N8"
N = eval(Nombre)+1 = eval("N8")+1 = 9999999+1 = 9999999.99999999
y apartir de ahí no sé qué hace, pero ya eso es un error ¿mío o qué pasa? ¿el máximo valor que puede tener una variable en Macromedia Flash 5 es 9999999.99999999 no 10000000? ¿o sea no más de 7 caracteres enteros? No me resulta un problema, creo, pero ¿por qué sucede eso? ¿tiene sentido? Si se puede guardar textos largos ¿por qué no un número? ¿o con números largos calcula mal tal como ocurre cuando son decimales?

D3s0rd3n:
Más bien tiene que ver con una limitacion de los números flotantes en general. Es una consecuencia de que no todos los números decimales pueden ser representados exactamente con un número binario. Hay "hacks" y algoritmos que ayudan a mitigar esto pero ya es una limitacion de las computadoras binarias en general. Algunas lo resuelven mejor que otras pero todas lo tienen.

Tachikomaia:
Pero estos números son enteros, se convierten a decimal sin que haya habido decimales de por medio.

Danielㅤ:
Hola, los números se convierten a decimales por las operaciones que hacés, un ejemplo sería una división que ingresas un número entero de 2 y lo divides por 4 te da como resultado un número decimal de 0,5


Saludos

EdePC:
Me parece que es problema de Flash 5, yo lo he probado en mi Macromedia Flash MX 2004 y sin problemas, incluso cuando exporto como Flash 5 desde ahí (Deberías migrar a Flash MS 2004 y AS2 XD)

Según la documentación de Math.pow()



Supongo que no lo terminaron de pulir porque yo veo que el compilado si que sale redondeado (he descargado e instalado Macromedia Flash 5 y un decompilador para comprobarlo)

El código original:

Código
trace( -1 + Math.pow(10, 8 - 1) )

Macromedia Flash 5 lo compila a:

Código
trace(9999998.999999994);

Macromedia Flash MX 2004 lo compila a:

Código
trace(9999999);

Pues arriba está aproximando y eso está causando tu problema, aunque se esté usando Flash 5 que supuestamente no usa aproximaciones. Una posible solución es forzar un redondeo con Math.Round:

Código
trace( Math.Round(-1 + Math.pow(10, 8 - 1)) )

---
Para ver como se termina compilando un swf se puede usar un decompilador flash, en mi caso usé JPEXS, un decompilador te permite ver a que instrucciones reales se convierte un script, y que el reproductor flash entiende

Navegación

[0] Índice de Mensajes

[#] Página Siguiente