No sabía bien dónde poner este topic, pero lo dejo acá que creo que está bien.
El otro día en el laburo se nos ocurrió probar algo loco en la compu: 20000! (veintemil factorial).

Sabemos que las calculadoras comunes (como la vieja y querida Casia Equation) no pueden resolver más de 35! o algo por ahí. Las más modernas llegan a 60!

Así que decidimos probar en nuestra herramienta de trabajo predilecta: Smalltalk.

Tan fácil como abrir la aplicación, escribir "20000 factorial" y evaluarlo. Díganme si existe algún otro entorno de desarrollo donde sea tan rápido y sencillo hacer ésto!!!!

En fin, ¿resultados?

En VisualAge Smalltalk tardó bastante, pero lo hizo. Me muestra el resultado con toooooooooodos los números.
En VisualWorks (por lejos el mejor Smalltalk de hoy en día) tardó unos 2 segundos, y también mostró el resultado completo.
En Squeak lo cortamos, porque tardaba demasiado y necesitábamos seguir trabajando, así que no pudimos ver el resultado, pero seguro lo estaba calculando.

Recuerdo en mi cursada de Paradigmas que la función factorial era una clásica de Haskell (funcional), y que llegué a sacar números grandes (no tanto como 20000), pero era muy lenta.

Después se me ocurrió probar con la calculadora de Windows, y sorprendentemente lo resolvió en 2 segundos, mostrando el resultado en notación científica (como todas las calculadoras).

En fin, no creo que nunca en mi vida llegue a utilizar el 20000! para algo, pero son unas de esas cosas locas que uno a veces se plantea, como "¿podré saltar de un 1er piso sin lastimarme?" (sí, alguna vez lo hice), y que necesita probar para sacarse la duda.

Estaría bueno que prueben de hacerlo en sus trabajar, con Java, .NET o lo que usen, y nos cuenten sus resultados.
La idea no es armar una competencia ni nada por el estilo, simplemente saber de qué cosas es capaz un lenguaje y la capacidad de un procesador.

Para realizar operaciones avanzadas, en general, es preferible hacer uso de algún programa optimizado para tal fin. Por ejemplo, el Mathematica hace ese tipo de cosas, y es completísimo.

Estoy casi seguro que ofrece una API para poder comunicarse con el programa, gracias a la cual se puede sacar el mayor potencial para resolver problemas matemáticos complejos.

Los lenguajes tradicionales capaz no tienen tan optimizadas esas instrucciones porque el fin principal de ellos no es ese, pero programas como el Mathematica están desarrollados por gente que busca la máxima performance (algoritmos de baja complejidad computacional pero alta complejidad a la hora de ponerselos a leer ), para ser utilizado en aplicaciones científicas.
Por otro lado, es obvio que sí vos te ponés a hacer el algoritmo para calcular el factorial, tardaría muchísimo más y, peor aún, provocaría overflow porque las variables de datos tradicionales que usamos no permiten números tan grandes. Para solucionar estos problemas, se utilizan estructuras más complejas y operaciones optimizadas (por ejemplo, probablemente requiera incluso redefinir la multiplicación entre dos números).

Bueno, aun no lo probé porque uso VB6 y no sé si hay función para sacar el factorial xD, pero después me fijo.

Saludos!

Multi-threading a pleno Capaz en un rato armo una prueba, depende de si cae algún bug del sistema que subimos ayer a producción o no . (ahora estoy haciendo el TP de TADP )

Ah, corrección en mis resultados, que ahora que leí lo de pablo me acordé.
En VisualAge nos tiró overflow. Lo que hice después fue copiar la implementación de Visual Works en Visual Age, y ahí sí funcionó, aunque tardó muchísimo más por la forma en que maneja la memoria y todo eso.

Como dijo Lean 1 (?), el multithreading es una buena opción. De hecho, muchos problemas que son muy complejos reducen su tiempo de ejecución radicalmente cuando se manejan como subproblemas en paralelo, incluso, a veces puede resultar mucho más conveniente utilizar aproximaciones, es cuestión de buscar qué es lo que hicieron investigadores de computación o matemáticos... y la Wikipedia no podía estar lejos de eso:

http://es.wikipedia.org/wiki/F%C3%B3rmula_de_Stirling

Señores, para valores de n grandes, a algún groso llamado Stirling se le ocurrió como aproximarla por medio de una fórmula. Si se fijan bien, se obtiene mayor precisión si se toman más términos de la serie (como bien pasaba en Análisis I).

Así, un cálculo que podía ser complicadísimo se convierte en otro complicado, pero no tanto .

Finalmente, para que vean que realmente es útil, mamá Wikipedia (Google es papá xD) nos dice:

Cita:La fórmula resulta útil en diversas áreas como la mecánica estadística, donde aparecen ecuaciones que contienen factoriales del número de partículas. Puesto que en la materia ordinaria los sistemas macroscópicos típicos tienen en torno a N = 10^{23} partículas la fórmula de Stirling resulta muy aproximada. Además la fórmula aproximante de Stirling es diferenciable lo cual permite el cálculo muy aproximado de máximos y mínimos en expresiones con factoriales.

Imaginen el factorial de 10^23...!!! Zarpado...

a ver con C en una de las maquinas del laboratorio de "Sistemas Operativos"...

Cita:Segmentation Fault

y despues quieren que ande mi tp!!! xD
jajaja es un chiste leito!
el ayudante que nos evaluo en diciembre es un FENOMENO

Yo use para mi cursada de analisis I un programa que se llama Derive, y tambien se me ocurrio el 2000! entre otras y lo resolvio bastante bien jeje

Off-topic:

LeaTex escribió:"¿podré saltar de un 1er piso sin lastimarme?" (sí, alguna vez lo hice),

¿Pero te tiraste?

asi0novamas escribió:

Off-topic:

LeaTex escribió:"¿podré saltar de un 1er piso sin lastimarme?" (sí, alguna vez lo hice),

¿Pero te tiraste?

Off-topic:

Por supuesto. Tenía unos 7 años. Me subí a un techo (unos 3 metros) y como no pude bajar por el mismo lugar que subí, me tiré. Caí re-bien.

 

Dim j As Long

j = 1

Do

j = j * Int(Text1.Text)

Text1.Text = Text1.Text - 1

Loop Until Text1.Text = 0

MsgBox j

Llega hasta el factorial de 12, que triste el visual basic.
Me quedo con la calcu vieja . y si declaras como integer peorrrr.

Probe declarandolo como Double y me tira cuando pongo por ej. 50 esto:
3.04140932017134E+64

alguien tiene idea de que es?

eduS escribió:Probe declarandolo como Double y me tira cuando pongo por ej. 50 esto:
3.04140932017134E+64

alguien tiene idea de que es?

Es un número en notación científica.
Significa
3,04... * 10^64

(tres con cero cuatro, por diez elevado a la sesenta y cuatro).
O sea que ahí atrás van 64 ceros. Realmente poco comparado con la contidad de números que tiran otros motores.

Gracias por la aclarion LeaTex!

Abrazo

¿Nadie más se copa con ésto?
Estaba leyendo un poco de Ruby, y me quedé pensando si lo resolvería. ¿Alguno usa Ruby y puede hacer la pruba?
O en algún otro lenguaje.

si queres algo loco bajate el superPI y calculate un numero PI de 32mb (va a tardar bastantes minutos jejej segun tu procesador)

Ahora que me arme la pc y entre a husmear en el overclockin encontre ese programa que es una forma de "testear" tu micro teniendo la posibilidad de calcular el numero PI en distintas dimensiones.

estuve probando un rato en phyton, no la tengo muy clara, asi que por ahi no son las mejores formas de calcular. Con la clasicas:

 def factorial(n): return int(n==0 or n*factorial(n-1))

moria con valores altos, despues de redefinir el limite de recursividad, tambien, asi que buscando recomendaban asi:

 sys.setrecursionlimit(20001)

def facto(n): return reduce(operator.mul, range(1, n+1))

y fue como piña, me tiro todos los numeros, y en un core2duo se tomo como 4 segundos

Me parecio interesante la idea, mas alla de que me viene bien para practira phyton :P

             function factorizar(valor){

                if (valor == 1 || valor == 0) 

                    return 1;

                else 

                    return valor * factorizar(valor - 1);

            }

            

            alert(factorizar(20000)); 

Js no se lo banca , el maximo es 1.7976931348623157e+308 ,despues tira infinity

Igual tirar error "too much recursion".