Foro - Perl en Español

¡Hola de nuevo! Estoy haciendo un programa de mutaciones aleatorias y he visto en muchos ejemplos esta orden, pero no sé lo que significa, ni si es imprescindible para el programa:

srand(time|$$)

Esa instrucción inicializa la semilla de números aleatorios que se utilizará con rand(). Como argumento tiene la función time(), que devuelve el número de segundos que han pasado desde el uno de enero de 1970. A ese valor, le aplica la operación bit a bit OR, con el valor almacenado en la variable especial $$, que suele ser el número de proceso para ese programa, en el momento de la ejecución, para el sistema operativo (pid).

Recuerda: cuando no sepas lo que es algo, prueba a buscarlo con perldoc, en tu propio ordenador:

perldoc -f srand

perldoc -f time

La información sobre la variable $$ está dentro del documento perlvar. Más información en tu propio ordenador en perldoc perlvar, y en la Web (traducido al español).

Hola, ¿alguien por favor podría explicarme por qué dentro del bucle for, en $mutant = mutate($mutant);, dentro del paréntesis va $mutant? ¿No es una función, verdad? ¿Es como un índice o qué es?

Gracias de antemano, si alguien puede explicarme esto, por favor. Saludos.

Bienvenido a los foros de Perl en Español, eduardoemen.

Sencillamente, es una llamada a una función, mutate(), que está definida en la línea 22.

Quizás llama la atención el hecho de que le estamos pasando como argumento el nombre de una variable, que a su vez recibirá el resultado de la llamada de la función.

Pero es que precisamente es el modo de funcionamiento del programa... una cadena de ADN es mutada, una base cada vez. La cadena de ADN la pasamos como argumento a la función, y ésta nos devuelve la cadena mutada, así que la guardamos en la misma variable, para que el bucle la vuelva a mutar en la siguiente vuelta.

Hola, buenos días, en un par de ejemplos he visto que hay que determinar una semilla con srand, por ejemplo:

y también en:


El asunto es que si saco srand los programas igualmente generan números y letras ( en el segundo ejemplo ) aleatorias.

Mi pregunta es si alguien puede ayudarme, por favor, es: ¿en qué necesidad hay de srand si igual funcionan bien sin dicha función?

Sigo sin comprender srand(time|$$), es que tengo un cursito básico de introducción a la bioinformática y me gustaría compartir con mis alumnos un ejemplo que hay en un pdf llamado Scripting para bioinformáticos. Se trata de simular mutaciones de ADN, pero la explicación es un poco compleja, si podrías por favor ayudarme con una explicación más detallada y sencilla.

Gracias de antemano y un saludo.

El objetivo de srand es la de poner una semilla en el motor generador de números aleatorios, para que éste genere una secuencia de números aleatorios.

De alguna manera, si le damos una semilla diferente cada vez, tendremos -casi- garantizadas siempre una diferente secuencia.

Y lo contrario también es cierto: si siempre damos el mismo número de semilla, saldrá la misma secuencia de números, lo cual es muy interesante para la repetición de experimentos.

Por ejemplo, hace años hice un programa que generaba montañas fractales. El programa pedía al principio el número de semilla. Si al final, la escena me gustaba, me apuntaba el número de semilla que había usado. Así, podía volver a ejecutar el programa más tarde, con esa misma semilla, y salía la misma escena.

srand(time|$$) quiere decir:

• time es la función que devuelve el número de segundos que han pasado desde 1 de enero de 1970. Ver perldoc -f time
• el operador '|' realiza la operación lógica OR bit a bit, entre los dos operandos. Ver perldoc perlop, sección Bitwise Or and Exclusive Or
• la variable especial $$ contiene el número de proceso dentro del sistema (el PID) del proceso que se estamos ejecutando en ese momento. Ver perldoc perlvar
• al resultado de la operación OR, lo pasamos a srand(), como semilla

Resumen: el programador realiza un procedimiento para tener un número de semilla lo suficientemente aleatorio, ya que lo crea a partir de la fecha actual y del número de proceso en ejecución.

Si no se llama a srand(), rand() la llama de forma automática la primera vez que es llamada (ver perldoc -f rand). Dice la documentación de srand() que si no elegimos una semilla, la eligirá de forma semi-automática.

Hola, si alguien me puede ayudar por favor con un par de sentencias que no sé exactamente cómo funcionan en detalle, comprendo más o menos de qué van pero no en profundidad y detalle.
Se trata de:

return $array[ rand @array ];

y

return int rand length $string;

Poco a poco, tenemos que ir explicando todo el programa

return $array[ rand @array ];

@array es una variable de array, así que guarda una serie de elementos.
rand() requiere un argumento escalar. Entonces, lo que hace Perl es ejecutar el array en contexto escalar, así que lo que obtenemos es el número de elementos que hay dentro de ese array.
rand(), con un argumento, devuelve un número aleatorio entre 0 (incluido) y el valor del argumento (excluido).
El valor aleatorio se transforma en un índice para extraer un elemento dentro del propio @array, y eso es lo que devuelve return().

En resumen: return() nos termina la subrutina actual, devolviendo un elemento de @array elegido aleatoriamente.

return int rand length $string;

length() nos devuelve el número de caracteres de $string.
rand() nos devuelve un número aleatorio entre 0 (incluido) y el valor del argumento (excluido).
int() redondea el número aleatorio a un número entero, y es este el valor que devuelve.

En resumen: return() nos termina la subrutina actual, devolviendo un número aleatorio entre 0 y la longitud de $string, menos 1 (o sea, que podemos usar ese número para sacar un carácter del interior de $string).

Hola, antes de nada, muchas gracias por tu ayuda, me está siendo de mucho provecho.

He variado un poco el programa para que me quede más claro a la hora de explicarlo.

Si puedes, por favor, ayúdame con un par de dudas que me han aparecido. Primero, ¿qué hace exactamente la subrutina 4? y segundo, ¿los resultados de $position (la posición al azar es...) ni elemento al azar ($elementoazar) tienen nada que ver con el nucleótido mutado? Ya que substr() y $newbase sí "funcionan", por ejemplo: donde había substr() se ha cambiado a $new.

De antemano, muchas gracias:

#!C:\Perl\perl.exe

my $DNA="TACGTACGTACG";

my(@nucleotides) = ('A', 'C', 'G', 'T');
my $elementoazar=randomelement(@nucleotides);
print ("el elemento al azar es:$elementoazar\n");

my($position)= randomposition($DNA);
print ("la posicion al azar es: $position\n");

$mutant=mutate ($DNA);
print ("la secuencia mutada es:$mutant\n");

my ($newbase)= randomnucleotide( @nucleotides );
print ("randomnucleotide es $newbase \n");


############
#subrutina 1#
###########
sub mutate {
my($dna) = @_;
my(@nucleotides) = ('A', 'C', 'G', 'T');
my($position) = randomposition($dna);
my($newbase) = randomnucleotide(@nucleotides);
print ("newbase es $newbase\n");
$x=substr($dna,$position,1,$newbase);
print ("el resultado del substr es: $x\n");
return $dna;
}


############
#subrutina 2#
###########
sub randomelement {
my(@array) = @_;
return $array [rand @array];
}


############
#subrutina 3#
###########
sub randomposition {
my($string) = @_; # Cuando una subrutina recibe parámetros, éstos son pasados como una lista en la variable-array especial
# @_; así recibe la subrutina los parámetros pasados, copiándolos del arreglo global @_ a variables locales.
return int rand length $string;
}


############
#subrutina 4#
###########
sub randomnucleotide{
my (@nucleotides)=("A","C","G","T");
return randomelement(@nucleotides);
}

eduardoemen escribiste:¿qué hace exactamente la subrutina 4?

Define el array @nucleotides con cuatro elementos, que son las cuatro famosas letras. Luego, pasa ese argumento a la función randomelement(), y el resultado de esa llamada es lo que devuelve con el return().

eduardoemen escribiste:y segundo, ¿los resultados de $position (la posición al azar es...) ni elemento al azar ($elementoazar) tienen nada que ver con el nucleótido mutado? Ya que substr() y $newbase sí "funcionan", por ejemplo: donde había substr() se ha cambiado a $new.

Los valores de $position y $elementoazar son elegidos al azar. El primero es según la longitud en caracteres, y el segundo, en función del número de elementos de un array.

Estas variables no tienen influencia en el proceso de mutación, ya que existen otras variables que se llaman igual y hacen lo mismo, dentro de mutate().