Que opinan de mi algoritmo? ::

Pues la verdad que no estaría yo tán seguro de que es más rentable si usar Math.floor+Math.random o random

A Nivel de máquina está claro que un random específico para enteros es mucho más eficiente, menos memoría. En cambio en Flash todo son "Number"s e imagino/creo que los reservará todos como flotantes de doble precision, pero como ya digo no sé

Lo que está claro que esas diferencias solo se verían cuando realmente necesitáramos optimizar al máximo nuestro script por el hecho de manejar muchos datos o tener poca memoria...

jajaja

me estas haciendo recordar lo q luche en la facu hace un dos años con las listas

Che... pero al final para q sirve ese algoritmo... no le encontre una utilidad... bah talvez porq son las 5 de la mañana...


saludos!

Tres cosillas:
Random() o Math.floor() y Math.random()
El motivo de la recomendación de Macromedia no es por la velocidad, es por la "eficiencia". Ambos son evidentemente pseudoaleatorios. Eso quiere decir simplemente que random() es menos aleatorio que Math.random(). Digamos que es posible y al que le interese le paso un trabajillo en mathlab donde se encuentra la pauta random() a partir de multiples miniseries de Poison. De poco sirve una funcion para declarar aleatoriedad que se pueda quemar. Lo que lleva a la segunda cosilla:

Uso del algoritmos de ordenación aleatoria
Aparte de la necesidad de mezclar aleatoriamente una lista o Array en muchísimos juegos de inteligencia Artificial y/o estrategia personalmente no estoy por la labor de que el señor ABAD esté siempre el primero de la lista en detrimento del señor ZUNZUNEGUI y si no que se lo pregunte a la hora de repartir caramelos en clase.... nunca le llegaban por que el profesor era algo zote en el cálculo de la partición. O a todos esos que colocan nombres para listas con "vete a saber cuantos" ascii bajos para estar de los primeros.
Bromillas aparte en IA son importantísimas. Y en lógica difusa, las básicas
Las 5 de la mañana es muy tarde ......o muy pronto para las neuronas.


El algoritmo de burbuja aleatoria de orden descendente.
Que así se suele denominar, es realmente rapídisimo.
No coloca a mayores más que la variable aleatoria mas el obligado contador, y aunque en el ejemplo que puse el bucle es de n para mezclar n (es para permitir poner un trace dentro del bucle que muestre todo el reordenamiento) , ciertamente es de n-1 para mezclar n. Podemos perfectamente poner en el for como condición de parada/continuidad i>1 en lugar de i>0. El último no tiene donde ir salvo quedarse donde está. Ejem: Si de 3 coloco 2 el tercero ya esta el el sitio correcto (el que queda).
A mayores: Podemos ir extrayendo los resultados en cada bucle sin esperar a que termine el ordenamiento!! pues su almacenamiento de orden ya está efectuado. Aunque hay otros que lo tambien lo hacen. Esperamos que Adobe ponga en el proximo AS un sortOn.ALEATORY.
Una curisidad no documentada por ningún sitio y relativo a las salidas sortOn:
Si pedimos la -8 nos da no los valores de los campos ordenados ascendente como en 16 sino el indice de esos campos en orden ascendente. Y -1 en lugar de 16 | 2 para los indices en orden descendente.

Si Daneel, de hecho hay muchos que comentan lo mismo que tu. Si lo dicen debe ser por algo.

Yo la razón en parte tiene que ver con lo que dice theNinjaBunny, y otras cosas que leí en mm acerca de Math.

Pero olvidandonos de esto, me encantaría ver la cara de un cliente diciendole:

alfathenus escribió:

es muy útil para desarrollar programas de estadística o probabilidad con una inmensa cantidad de datos... especialmente cuando se requiera tomar una muestra y con esa muestra [muestra grande (mayor a 30... en términos de estadistica)] realizar un análisis detallado como desviaciones, varianza y todo lo relacionado a las medidas de dispersión y miscelaneos...

dano escribió:

je... la verdad si....

y es que la verdad en función al equipo en el que ejecutemos el programa en mi opinión personal no abria mucha diferencia o si?... ahora me pregunto que ocurriría en otros lenguajes....

Para la estadística:

Código :

Ciclos = 500;
Tiempo = getTimer();
texto = "Texto de prueba";
for (var i = 0; i<Ciclos; i++) {
   Math.round(Math.random()*i);
}
trace(Ciclos+" ciclos de Math.round(Math.random()) -> "+(getTimer()-Tiempo)+" Milisegundos");
Tiempo = getTimer();
for (var i = 0; i<Ciclos; i++) {
   random(i);
}
trace(Ciclos+" ciclos de Random() -> "+(getTimer()-Tiempo)+" Milisegundos");
//Aleatorio grado de...
aMathRandom = new Array();
for (var i = 0; i<Ciclos; i++) {
   agregaNuevo(Math.round(Math.random()*Ciclos), aMathRandom);
}
trace("Total de elementos: "+Ciclos+" - Math.random obtuvo: "+aMathRandom.length+" elementos que no se repitieron");
aRandom = new Array();
for (var i = 0; i<Ciclos; i++) {
   agregaNuevo(random(Ciclos), aRandom);
}
trace("Total de elementos: "+Ciclos+" - random obtuvo: "+aRandom.length+" elementos que no se repitieron");
function agregaNuevo(Value:Number, ds:Array):Void {
   if (noExiste(Value, ds)) {
      ds.push(Value);
   }
}
function noExiste(aValue:Number, ads:Array):Boolean {
   for (j in ads) {
      if (ads[j] == aValue) {
         return false;
      }
   }
   return true;
}

Conclusiones mías
- La función Random(depreciada), como comenta Daneel, es mas rápida.
- La probabilidad de aleatoriedad es muy similar en random y Math.random

De hecho, si sustiyutes floor por round (más correcto) verás que la precisión es prácticamente idéntica, aunque sigue ganando por poco el Math.random

Código :

CiclosdeCiclos = 500;
Ciclos = 10;
Numeros = 3;
pbrd=[] ; pbr=[] ; pbf=[]; 
cdn=new Array("random","round","floor") 
factor=100/(CiclosdeCiclos*Ciclos);
for (var i = 0; i<Numeros; i++) {pbrd[i]=0;pbr[i]=0;pbf[i]=0;}
for (var i = 0; i<3; i++) { math_tipo(i);}
function math_tipo(tipo){
   trace (cdn[tipo])
   for (var j = 0; j<CiclosdeCiclos; j++){
      b=""; num=[];
      for (var i = 0; i<Numeros; i++) {num[i]=0;}
      for (var k = 0; k<Ciclos; k++) {
         a = random(Numeros)                       *(tipo==0) +
             Math.round( Math.random()*(Numeros-1))*(tipo==1) +
             Math.floor( Math.random()* Numeros)   *(tipo==2) 
                             
         b+=" "+a; num[a]+=1;
           pbrd[a]+=1*(tipo==0);pbr[a]+=1*(tipo==1);pbf[a]+=1*(tipo==2);
      }
      // para no saturar, usar con Ciclos y ciclosdeCiclos  pequeños
      //trace("Serie usando "+ cdn[tipo] +":" + b);
       //for (var i = 0; i<Numeros; i++){trace( "Con "+cdn[tipo]+
      //    " En Ciclo "+(j+1)+": Veces de "+i+": "+ num[i]) ;}
   }
   for (var i = 0; i<Numeros; i++) {
      trace( "       Probabilidad de "+ i+": "+ 
       factor*(pbrd[i]*(tipo==0)+pbr[i]*(tipo==1)+pbf[i]*(tipo==2))+"%");
   }

Conclusiones en cuanto a aleatoreidad, velocidad y corrección:

random() :
Es suficientemente aleatorio para la mayoria de los ejercicios y < Math.random
Su "semilla" puede ser detectada. No se debe usar en juegos de azar matemático.
Es el más rápido.

Math.round(Math.Random) :
Es totalmente erroneo respecto a la igualdad de probabilidades.
Probabilidad de los 2 extremos = 1/2 Probabilidad de cualquier otro de la serie.
Solo se puede usar correctamente en la busqueda entre 2 valores (Numeros entre a y b)

Math.floor(Math.Random) :
Un poco mas lento que random()
La mejor aleatoreidad que ofrece este lenguaje y >random()

Hola Gabo del pasado.

Te recomiendo leer sobre esto:

Fisher–Yates shuffle: The modern algorithm

Aquí un bonito vídeo explicando todo: