Según GPT, Flash falla en guardar números demasiado grandes. Asumo que el problema es ese.

A ver, tengo una cadena que representa a un binario.

Necesito convertirlo en decimal, pero si es un número falla, así que necesito que sea una cadena.
¿Cómo convierto una cadena que representa a un binario, en una cadena que representa a un decimal? Sin convertirlo todo junto a número porque sino falla.

Luego a la cadena obtenida, que representa a un decimal, necesito dividirla por otro número, nunca tan grande. Y que el resultado sea una cadena también, porque puede ser muy grande.
¿Cómo a una cadena que representa a un decimal, la puedo dividir por un número, de modo que el resultado sea representado por una cadena? Mismo comentario.

Con eso tenemos Decimal y ResultadoDeDivision.

Por último, a Decimal necesito restarle ResultadoDeDivision varias veces, en un loop. Esto parece lo más sencillo, como hacer una resta manualmente, viendo cuales son los últimos caracteres.
¿Cómo a una cadena que representa a un decimal, le puedo restar otra que representa a otro? Mismo comentario.

O quizá sería más fácil hacer las operaciones usando las cadenas binarias, creo que no necesito los decimales.

Le preguntaré a GPT si nadie responde.

Intento resumir y corregir algunos posibles errores que haya cometido en posts anteriores.

Se consigue el número binario que forma la L invertida, aunque es un string:
"1111111011111110111111101111111011111110111111101111111000000000"

Se intenta convertir a decimal, pero como el número resultante es tan grande, Flash falla:
9.22337203685478e+18
Según GPT, el resultado debería ser 18374686492081295424 y el número raro que pone Flash es casi la mitad de eso. Falla.

Entonces, en principio necesito un método de convertir un string que representa un número binario, en un string que represente un decimal, pero sin que dicho método use variables tipo número que sean demasiado grandes, porque sino falla.

El método que usaba, para convertir DibujoEnBinario en DibujoaMostrar, es:

	// Convertirlo en decimal:
	DibujoaMostrar = 0;
	do {
		DibujoaMostrar = DibujoaMostrar+(Number(DibujoEnBinario.charat(NroDelCaracter))*Math.round(Math.pow(2, DibujoEnBinario.length-1-NroDelCaracter)));
		trace("Convirtiendo en decimal... "+DibujoaMostrar);
		NroDelCaracter++;
	} while (NroDelCaracter<Cuadraditos);
	DibujoaMostrar = Number(DibujoaMostrar);

Le expliqué a GPT y me dijo esto:

function binaryToDecimalString(binStr) {
    var decimal = "0";
    var i = 0;
 
    while (i < binStr.length) {
        // Multiplicar el decimal actual por 2
        decimal = multiplyDecimalStringByTwo(decimal);
 
        // Sumar el bit actual si es 1
        if (binStr.charAt(i) == "1") {
            decimal = addDecimalString(decimal, "1");
        }
 
        i++;
    }
 
    return decimal;
}
 
// Multiplica un string decimal por 2
function multiplyDecimalStringByTwo(decimal) {
    var result = "";
    var carry = 0;
 
    for (var i = decimal.length - 1; i >= 0; i--) {
        var digit = Number(decimal.charAt(i)) * 2 + carry;
        carry = Math.floor(digit / 10);
        result = String(digit % 10) + result;
    }
 
    if (carry > 0) {
        result = String(carry) + result;
    }
 
    return result;
}
 
// Suma dos strings decimales
function addDecimalString(a, b) {
    var result = "";
    var carry = 0;
    var i = a.length - 1;
    var j = b.length - 1;
 
    while (i >= 0 || j >= 0 || carry > 0) {
        var digitA = i >= 0 ? Number(a.charAt(i)) : 0;
        var digitB = j >= 0 ? Number(b.charAt(j)) : 0;
        var sum = digitA + digitB + carry;
        carry = Math.floor(sum / 10);
        result = String(sum % 10) + result;
        i--;
        j--;
    }
 
    return result;
}

Lo voy a pensar.

Luego creo que tendría que dividir un número entre otro, pero siendo strings, y también tendría que hacer restas usando strings.

En Flash 5 el número entero más grande con el que puedes trabajar es 9007199254740992 (2^53) en en algún momento operas superando ese valor se usarán aproximaciones que obviamente perderán precisión dependiendo cuan alejados estén al límite de 2^53.

Convertir no te sirve porque igual vas a llegar a superar ese valor al intentar realizar alguna operación. Las soluciones que tienes es buscar otra forma dependiendo de como funcione tu programa o lo que quieras lograr, o trabajar todo sin convertirlo completamente, por ejemplo si intentas convertir de binario_string a decimal se te complica porque debes hacer operaciones con números enormes al depender de operaciones que involucran cada caracter

En caso de convertir de binario_string a hexadecimal lo tienes muy sencillo porque tomas de 4 en 4 bits y los conviertes a hexadecimal concatenando todo y ya está, no es necesario trabajar con todos los caracteres ni operar con todos ellos a la vez PERO el problema viene cuando dices: luego debo dividir entre otro número, ahí se rompe todo porque lo tendrás que convertir a número, lo que podrías hacer es crear una función propia para hacer la división, ya sea trabajando todo en binario, o hexadecimal, o decimal (pidiéndole a ChatGPT una función rarísima que ni se entienda XD).

Pues si por ejemplo trabajas en binario_string puro y quieres dividir lo haces como se haría con papel y lápiz a mano (como en el colegio), si el trabajo lo va hacer ChatGPT pues mejor le pides que lo trabaje todo así sin hacer conversiones innecesarias, que cree una función que divida dos binario_string

Ahora bien, con respecto a las calculadoras, la de Windows obviamente no está preparada para esas locuras XD, aunque está el viejo Microsoft Mathematics que no tendría problemas pero es una aplicación más avanzadita, para hacer tus pruebas sin errores yo te recomendaría  SpeedCrunch https://heldercorreia.bitbucket.io/speedcrunch/download.html si deseas puedes bajar la versión instalable o la portable, es muy amigable para los programadores porque es sencillísima, una forma de poner a prueba la calculadora es operando, esta calculadora puede trabajar con números de hasta 78 dígitos sin perder precisión, Excel por otro lado solo puede con 15 dígitos. Por ejemplo con SpeedCrunch:

0b1111111011111110111111101111111011111110111111101111111000000000

Mira que puse el 0b delante, eso es para especificar que estás usando un binario tal cual es 0x para los hexadecimales. Con darle un Enter te devuelve en ese número en Decimal:

18374403900871474688

Servirá como referencia, ahora hago la siguiente operación:

0b1111111011111110111111101111111011111110111111101111111000000000 * 123456789

Como resultado me muestra: 2268444905390666566675256832

Ahora el resultado de la operación anterior lo divido entre 123456789 para ver si obtengo el mismo número de la referencia:

2268444905390666566675256832 / 123456789

Devuelve: 18374403900871474688 que es exactamente igual a la muestra, es más lo puedo convertir a binario con:

bin(18374403900871474688)

dando: 0b1111111011111110111111101111111011111110111111101111111000000000 que es exactamente el binario original, es decir, no pierdes nada de precisión

Hola dime si te sirve este codigo esta en javascript pegalo en el bloc de notas con extensión html

<html>
<head>
<body>
<center>
Numero Binario:<textarea id="bin" cols="200"></textarea><br>
<input type="button" value="Convertir" onclick="conver()"><br><br>
Numero Decimal:<textarea id="num" cols="200"></textarea>
</center>
<script>
function binarioGiganteADecimal(binario) {
    let decimal = 0n;
    for (let bit of binario) {
        decimal = (decimal << 1n) + BigInt(bit); // Desplazamiento binario
    }
    return decimal;
}
function conver()
{
   let binario = document.getElementById("bin").value;
   let decimal = binarioGiganteADecimal(binario);
 
   document.getElementById("num").value=decimal.toString();
}
</script>
</body>
</html>
 

Flamer:
Hice lo que dijiste, puse
1111111011111110111111101111111011111110111111101111111000000000
y el resultado fue
18374403900871474688

pero al hacerlo aquí:
https://masterplc.com/calculadora/convertir-binario-a-decimal/
fue
18374403900871475000

Y GPT dijo
18,446,744,066,181,791,744

Yo no sé


Ahora en un rato voy a hablar con él sobre el código que me dió porque no lo entendí. Luego actualizo.

Edit: Hablado hasta que me quedé sin puntos.

Resumen:
qué significa Saltar ceros líderes

explica esto
  while (i < n && bin.charAt(i) == "0") { i++; }
  if (i >= n) return "0";

no sé si el while ha terminado, etc. Lo veo así:
while (i < n && bin.charAt(i) == "0") {
   i++;
}
if (i >= n) return "0";
y sigue ¿es así?


cambié los i por NroDeCaracteraMirar:
(código)
¿tengo que cambiar los siguientes i o son independientes? Este:
  for (; i < n; i++) {


la variable n es el largo del binario, siempre?


var para qué es, qué diferencia hay entre definir una variable con var y sin var


No sabía o me había olvidado, a veces creaba variables y luego las eliminaba, de esta forma se eliminan solas.

cómo este if no tiene el { ?
  if (NroDeCaracteraMirar >= LargoDelBinario) return "0";
normalmente se pone
si (condición) {
   efecto


¿es posible que NroDeCaracteraMirar quede mayor que LargoDelBinario?
  // Ignorar ceros al inicio del binario:
  var NroDeCaracteraMirar = 0;
  var LargoDelBinario = bin.length;
  // Para eso mira caracteres desde la izquierda hasta que no haya caracteres o hasta que no sea 0:
  while (NroDeCaracteraMirar < LargoDelBinario && bin.charAt(NroDeCaracteraMirar) == "0") {
    NroDeCaracteraMirar++;
  }
  if (NroDeCaracteraMirar >= LargoDelBinario) {
   return "0";
  }

el incremento de NroDeCaracteraMirar ocurre sólo si es menor que LargoDelBinario, por lo que en cierto punto quedará igual y luego ya no aumentará, por lo tanto NroDeCaracteraMirar nunca será mayor que LargoDelBinario ¿correcto?


Código más claro (aún falta aclararlo más):

// Convierte un string binario (p.ej. "1101") a string decimal exacto (p.ej. "13")
// No usa Number para representar el valor completo, solo dígitos individuales.
function binToDecString(bin) {
  // Ignorar ceros al inicio del binario:
  var NroDeCaracteraMirar = 0;
  var LargoDelBinario = bin.length;
  // Para eso mira caracteres desde la izquierda hasta que no haya caracteres o hasta que no sea 0:
  while (NroDeCaracteraMirar < LargoDelBinario && bin.charAt(NroDeCaracteraMirar) == "0") {
    NroDeCaracteraMirar++;
  }
  // Si miró todos los caracteres:
  if (NroDeCaracteraMirar == LargoDelBinario) {
	return "0";
  }
 
  // digits almacena el número decimal en dígitos base 10, LSB primero (digits[0] es las unidades)
  var digits = [0];
 
  // Recorremos desde el primer '1' encontrado
  for (; NroDeCaracteraMirar < LargoDelBinario; NroDeCaracteraMirar++) {
    var c = bin.charAt(NroDeCaracteraMirar);
    if (c != "0" && c != "1") {
      continue; // o maneja error si prefieres
    }
 
    // decimal *= 2
    var carry = 0;
    var j;
    for (j = 0; j < digits.length; j++) {
      var x = digits[j] * 2 + carry;
      digits[j] = x % 10;
      carry = Math.floor(x / 10);
    }
    while (carry > 0) {
      digits[digits.length] = carry % 10;
      carry = Math.floor(carry / 10);
    }
 
    // decimal += bit
    if (c == "1") {
      var k = 0;
      var add = 1;
      while (add > 0) {
        if (k >= digits.length) digits[digits.length] = 0;
        var y = digits[k] + add;
        digits[k] = y % 10;
        add = Math.floor(y / 10);
        k++;
      }
    }
  }
 
  // Construir string (invertir los dígitos)
  var s = "";
  for (var t = digits.length - 1; t >= 0; t--) {
    s += digits[t];
  }
  return s;
}

EdePC te respondo otro día porque por hoy este tema me cansó/aburrió, pero a simple vista, sí, voy a tener que poner que el programa opere así, pero eso es un problema a resolver más adelante.