programar en ruby II

Variables

Hasta ahora, cuando usamos 'puts' para un texto o número, esto desaparece. A lo que me refiero es que, si queremos imprimir algo dos veces, necesitamos escribirlo dos veces:

Código:

puts '...puedes decir eso de nuevo...'
puts '...puedes decir eso de nuevo...'

Resultado:

...puedes decir eso de nuevo...
...puedes decir eso de nuevo...

Sería bueno si pudiesemos escribirlo solo una vez y quedárnoslo... guardarlo en algún lado. Bueno, sí podemos, por supuesto; de otra manera, ¡no lo hubiese mencionado!

Para guardar el texto en la memoria de tu computador, necesitamos darle un nombre al texto. Los programadores se refieren frecuentemente a este proceso como asignación y llaman a los nombresvariables. Esta variable puede ser cualquier secuencia de letras o números, pero el primer caracter necesita ser minúscula. Probemos nuestro programa de nuevo, pero esta vez voy a darle el nombre'myString' al texto (aunque podría haber usado cualquier nombre, por ejemplo 'str' o'myOwnLittleString' o 'enriqueOctavo').

Código:

myString = '...puedes decir eso de nuevo...'
puts myString
puts myString

Resultado:

...puedes decir eso de nuevo...
...puedes decir eso de nuevo...

En todo momento cuando haces referencia a 'myString', el programa usa en su reemplazo"'...puedes decir eso de nuevo...'". Puedes pensar en la variable 'myString' como "apuntando" al texto "'...puedes decir eso de nuevo...'". Este es un ejemplo un poco más interesante.

Código:

name = 'Patricia Rosanna Jessica Mildred Oppenheimer'
puts 'Me llamo ' + name + '.'
puts 'Wow!  "' + name + '" es un nombre realmente largo!'

Resultado:

Me llamo Patricia Rosanna Jessica Mildred Oppenheimer
Wow! Patricia Rosanna Jessica Mildred Oppenheimer es un nombre realmente largo!

También, así como podemos asignar un objeto a una variable, podemos reasignar un objeto diferente a esa variable (Por eso es que las llamamos variables: porque varían.)

Código:

composer = 'Mozart'
puts composer + ' fue "el amo", en su día.'

composer = 'Beethoven'
puts 'Pero yo prefiero a ' + composer + ', personalmente.'

Resultado:

Mozart fue "el amo", en su día.
Pero yo prefiero a Beethoven, personalmente.

Por supuesto, las variables pueden apuntar a cualquier tipo de objeto, no sólo texto:

Código:

var = 'solo otro ' + 'texto'
puts var

var = 5 * (1+2)
puts var

Resultado:

solo otro texto
15

De hecho, las variables pueden apuntar a casi cualquier cosa... excepto otras variables. ¿Pero qué pasa si lo intentamos?

Código:

var1 = 8
var2 = var1
puts var1
puts var2

puts ''

var1 = 'ocho'
puts var1
puts var2

Resultado:

8
8

ocho
8

Primero, cuando tratamos de apuntar var2 a var1 en realidad apuntamos a 8 (que es el valor al cual apuntaba var1). Luego cuando apuntamos var1 a 'ocho', el valor de var2 no cambia ya que en realidad no estaba apuntando a var1 sino a 8. Ahora que tenemos variables, números y textos, vamos a ver como mezclarlos.

Conversiones

Hemos revisado distintos tipos de objetos (números y textos) y hemos hecho que variables apunten a ellos; lo que queremos hacer después es que funcionen todos juntos.

Hemos visto que si queremos que un programa imprima 25, lo que sigue no funciona, porque no puedes sumar números y texto:

Código:

var1 = 2
var2 = '5'

puts var1 + var2

Resultado:

in `+': String can't be coerced into Fixnum (TypeError)

Parte del problema es que tu computadora no sabe si estabas tratando de obtener 7 (2 + 5) o si querías obtener '25' ('2' + '5').

Antes de poderlos sumar, necesitamos alguna forma de conseguir la representación textual (en 'letras') de var1, o la representación numérica de var2.

Conversiones

Para obtener la representación en texto de un objeto, simplemente escribiendo .to_s después del objeto:

Código:

var1 = 2
var2 = '5'

puts var1.to_s + var2

Resultado:

25

De la misma manera, to_i devuelve la versión numérica entera de un objeto y to_f devuelve la versión de punto flotante, o sea la que lleva decimales. Veamos que hacen estos tres métodos (y lo que no hacen) un poco más de cerca:

Código:

var1 = 2
var2 = '5'

puts var1.to_s + var2
puts var1 + var2.to_i

Resultado:

25
7

Nota que, inclusive después de que obtuvimos la versión en texto de var1 al llamar to_s, var1siempre apuntó a 2, y nunca a '2'. A menos que reasignes explícitamente var1 (lo que requiere de un signo =), apuntará a 2 durante la duración del programa.

Ahora probemos conversiones más interesantes (y un poco raras):

Código:

puts '15'.to_f
puts '99.999'.to_f
puts '99.999'.to_i
puts '5 es mi número favorito.'.to_i
puts '¿Quién pregunta acerca de 5 o lo que sea?'.to_i
puts 'Tu mamá hizo.'.to_f
puts 'fibroso'.to_s
puts 3.to_i

Resultado:

15.0
99.999
99
5
0
0.0
fibroso
3

Ésto probablemente te ha sorprendido un poco. El primero es bastante estándar, devolviendo 15.0. Después de eso, convertimos el texto '99.999' a un número de punto flotante y a un entero. El primero hizo lo que esperábamos; el entero fue, como siempre, redondeado hacia abajo.

Luego, tuvimos ejemplos de algunos textos... inusuales... convertidos a números to_i ignora lo primero que no entienda, y el resto del texto a partir de ahí. Así que lo primero va a ser convertido a5, pero los otros, ya que comenzaban con letras, fueron ignorados completamente... así que la computadora simplemente elige usar cero.

Finalmente, vimos que las últimas dos conversiones no hacían nada, tal como esperábamos.

Hay algo extraño en nuestro método favorito... Mira esto:

Código:

puts 20
puts 20.to_s
puts '20'

Resultado:

20
20
20

¿Por qué estas tres líneas retornan el mismo resultado? Bueno, las últimas dos deberían, ya que20.to_s es '20'. Pero, ¿qué pasa con la primera, el entero 20? Para tal caso, ¿qué significa escribir el entero 20? Cuando escribes 2 y luego 0 en un papel, estás escribiendo texto, no un entero.El entero 20 es el número de dedos que tengo; no es 2 seguido de un 0.

Bueno, ahí está el secreto de nuestro amigo puts. Antes de que puts trate de imprimir un objeto, usa to_s para obtener la versión en texto de ese objeto. De hecho, la s en puts significa string (que en español significa texto); puts realmente significa put string (que en español significa imprimir texto).

Esto puede no parecer muy emocionante ahora, pero hay muchos, muchos objetos en Ruby (¡inclusive vas a aprender a crear tus propios objetos!), y es bueno saber que va a pasar cuando trates de ejecutar puts con un objeto bastante raro, como la foto de tu abuela o un archivo de música, etc. Pero eso vendrá después ...

Mientras tanto, tenemos unos cuantos métodos para ti, y ellos nos permiten escribir todo tipo de programas divertidos...

Los Métodos gets y chomp

Si puts significa put string, estoy seguro que puedes adivinar que significa gets, get string (recibir texto). Y así como puts siempre devuelve texto, gets sólo funciona con texto. ¿Y de dónde lo recibe?

¡De ti! Bueno, de tu teclado, en realidad. Ya que tu teclado sólo escribe texto, todo funciona bien. Lo que realmente pasa es que gets simplemente lee todo lo que tipeas hasta que presionas Enter. Intentémoslo:

Código:

puts gets

Resultado:

*¿Hay eco aquí?*
¿Hay eco aquí?

Por supuesto, lo que sea que escribas simplemente será impreso en pantalla por ti. Ejecútalo unas cuantas veces e intenta escribir cosas distintas.

¡Ahora podemos escribir programas interactivos! En este caso, escribe tu nombre y te saludará:

puts 'Hola, ¿cuál es tu nombre?'
name = gets
puts '¿Tu nombre es ' + name + '?  ¡Es un nombre adorable!'
puts 'Encantado de conocerte, ' + name + '.  :)'

Uhm! Acabo de ejecutarlo, escribí mi nombre y esto es lo que he obtenido:

Hola, ¿cuál es tu nombre?
*Chris*
¿Tu nombre es Chris
?  ¡Es un nombre adorable!
Encantado de conocerte, Chris
.  :)

Hmmm... parece que cuando escribí las letras C, h, r, i, s, y luego presioné Enter, gets recibió todas las letras de mi nombre y el Enter! Afortunadamente, hay un método para este tipo de cosas:chomp. Ésto elimina cualquier Enter al final del texto. Intentémoslo de nuevo, pero con chomppara que nos ayude:

Código:

puts 'Hola, ¿cuál es tu nombre?'
name = gets.chomp
puts '¿Tu nombre es ' + name + '?  ¡Es un nombre adorable!'
puts 'Encantado de conocerte, ' + name + '.  :)'

Resultado:

Hola, ¿cuál es tu nombre?
Chris
¿Tu nombre es Chris?  ¡Es un nombre adorable!
Encantado de conocerte, Chris.  :)

¡Mucho mejor! Nota que ya que name apunta a gets.chomp, no tenemos que usar name.chomp;name ya fue procesado por chomp.

Algunas cosas por intentar

• Escribe un programa que pregunte por el nombre de una persona, luego el segundo nombre y luego el apellido. Finalmente, debería saludar a la persona con el nombre completo.

Métodos

Hemos visto diferentes métodos: puts, gets, etc. (Prueba: Listar todos los métodos que hemos visto hasta ahora!. Hay diez de ellos, la respuesta está abajo), pero no hemos realmente hablado sobre que hacen los métodos. Sabemos que hacen, pero no lo que son.

Pero realmente, esto es lo que son: cosas que generan otras. Si objetos (como textos, enteros y flotantes) son los sujetos en el lenguaje Ruby, entonces los métodos son como verbos. Y, justo como en el español, tú no puedes tener un verbo sin un sustantivo para hacer algo. Por ejemplo, tic-tac no es algo que sólo ocurre; un reloj (o algo) tiene que hacer esto. En español podemos decir: "El reloj hace tic-tac". En Ruby podemos decir clock.tick (asumiendo por supuesto que clock es un objeto Ruby). Los programadores pueden decir que estamos "llamando el método tick de clock" o llamamos al "tick de clock".

Entonces, ¿has hecho la prueba? Bien. Bueno, estoy seguro que recordarás los métodos puts, getsy chomp; dado que ya hablamos sobre ellos. Probablemente también recuerdas los métodos de conversión to_i, to_f, y to_s. Sin embargo, ¿has visto los otros cuatro? Porque, estos no son otros que nuestros viejos amigos para la aritmética ¡+, -, * y /!

Entonces, como cada verbo necesita un sustantivo, entonces cada método necesita un objeto. Esto es generalmente fácil de indicar: es el que viene justo antes de un punto, como nuestro ejemploclock.tick, o en 101.to_s. Algunas veces, sin embargo, esto no es tan obvio; como con los métodos aritméticos. Como resulta, 5 + 5 es solo otra forma fácil de escribir 5.+ 5. Por ejemplo:

Código:

puts 'hola '.+ 'mundo'
puts (10.* 9).+ 9

Resultado:

hola mundo
99

Esto no es muy lindo, por lo que no vamos a escribir siempre como ahora; sin embargo, es importante para entender que sucede realmente.

Esto también nos da un profundo entendimiento de porque podemos hacer 'pig'*5 pero no podemos hacer 5*'pig': 'pig'*5 está diciendo a 'pig' de hacer de multiplicando, pero5*'pig' está diciendo a 5 de hacer de multiplicando. 'pig' sabe como hacer 5 copias de si mismo y agregar todos ellos juntos; sin embargo, 5 tendrá mucha más dificultad en tiempo de hacer 'pig' copias de si mismo y sumarlos a todos juntos.

Y, por supuesto, continuaremos teniendo puts y gets para explicar. ¿Dónde están sus objetos? En español, puedes algunas veces dejar fuera el sustantivo; por ejemplo, si un villano grita "¡Muere!", el sustantivo implícito es a quien él está gritando. En Ruby, si digo puts 'ser o no ser', lo que realmente estoy diciendo es self.puts 'ser o no ser'.

Entonces ¿qué es self? Ésta es una variable especial que apunta al objeto en el que estás. No siempre sabemos como estar en un objeto, pero hasta que nos demos cuenta, siempre iremos a estar en un gran objeto que es... ¡el programa entero! (sin embargo en este caso no es posible llamarlo en forma explícita). Observa lo siguiente:

Código:

NoPuedoCreerQueUnaVariableConNombreTanLargoApunteA3 = 3
puts NoPuedoCreerQueUnaVariableConNombreTanLargoApunteA3
self.puts NoPuedoCreerQueUnaVariableConNombreTanLargoApunteA3

Resultado:

3
in `<main>': private method `puts' called for main:Object (NoMethodError)

Si no alcanzaste a comprender todo, está bien. Lo importante es que todo método está siendo propiedad de un objeto, incluso si no tiene un punto enfrente de éste. Si entiendes esto estás preparado.

Métodos imaginativos acerca de Strings

Vamos a aprender unos pocos pero interesantes métodos. No tienes porque memorizar todos; puedes mirar esta página de nuevo si te olvidas de alguno. Yo sólo quiero mostrarte una pequeñaparte de lo que puede hacer un texto. De hecho, no recuerdo ni siquiera la mitad de los métodos para textos; pero está bien, porque hay buenas referencias en internet con todo acerca de textos listados y explicados (Voy a mostrarte donde encontrar esas referencias al final del tutorial).

Realmente, tampoco quiero saber todo acerca de los métodos para textos; sino sería como tratar de conocer cada palabra en el diccionario. Puedo hablar español bien sin conocer cada una de las palabras del diccionario... ¿y no es ese realmente el objetivo del diccionario? Entonces ¿no tienes que conocer que hay en éste?

Entonces, nuestro primer método para texto es reverse, el cual nos da una version invertida de un texto:

Código:

var1 = 'parar'
var2 = 'subrayado'
var3 = 'Puedes pronunciar esta oración al revés?'

puts var1.reverse
puts var2.reverse
puts var3.reverse
puts var1
puts var2
puts var3

Resultado:

rarap
odayarbus
?séver la nóicaro atse raicnunorp sedeuP
parar
subrayado
Puedes pronunciar esta oración al revés?

Como puedes ver, reverse no revierte el orden en el string original; éste sólo hace una nueva versión de éste en reversa. Esto es porque var1 continua 'parar' aún después de que llamamosreverse sobre var1.

Otro método para texto es length, el cual nos dice el número de caracteres (incluyendo espacios) en el texto:

Código:

puts '¿Cuál es tu nombre completo?'
name = gets.chomp
puts '¿Sabes que hay ' + name.length + ' caracteres en tu nombre, ' + name + '?'

Resultado:

¿Cuál es tu nombre completo?
Christopher David Pine
in `+': no implicit conversion of Fixnum into String (TypeError)

¡¡Uhh!! Algo salió mal, y esto parece que ocurrió después la línea name = gets.chomp... ¿Puedes ver el problema? Fijate si puedes darte cuenta.

El problema es con length: esto te devuelve un número, pero nosotros queremos un texto. Esto es fácil, necesitamos solo agregar to_s (y cruzar nuestros dedos):

Código:

puts '¿Cuál es tu nombre completo?'
name = gets.chomp
puts '¿Sabías que hay ' + name.length.to_s + ' caracteres en tu nombre, ' + name + '?'

Resultado:

¿Cuál es tu nombre completo?
Christopher David Pine
Sabías que hay 22 caracteres en tu nombre, Christopher David Pine

No, no conocía esto. Nota: esto es el número de caracteres en mi nombre, no el número de letras. Supongo que podríamos escribir un programa el cual nos pregunte por nuestro primer nombre, segundo nombre y apellidos individualmente, y entonces sumar estos tamaños todos juntos... hey, ¡porque no haces esto! Comienza, esperaré.

¿Lo hiciste? ¡Bien! Es un lindo programa, ¿no? Después de unos pocos capítulos más, pienso, estarás sorprendido de lo que podrás hacer.

Entonces, hay también un número de métodos para texto los cuales cambian el contenido (mayúsculas y minúsculas) de tu texto. upcase cambian cada minúscula por mayúscula. swapcasecambia en cada letra en el string("Hola".swapcase #=> "hOLA"), y finalmente, capitalize es comodowncase, excepto que esto cambia solo el primer carácter a mayúsculas (si es una letra).

Código:

letters = 'aAbBcCdDeE'
puts letters.upcase
puts letters.downcase
puts letters.swapcase
puts letters.capitalize
puts ' a'.capitalize
puts letters

Resultado:

AABBCCDDEE
aabbccddee
AaBbCcDdEe
Aabbccddee
 a
aAbBcCdDeE

Esto es bastante estándar. Como puedes ver desde la linea puts ' a'.capitalize, el métodocapitalize sólo deja en mayúsculas el primer carácter, no la primera letra. También, como hemos visto antes, en todas estas llamadas a métodos, letters permanece igual. No quiero ser pesado con esto, pero es importante entenderlo. Hay algunos métodos los cuales hacen cambios a los objetos asociados, pero no los hemos visto aún, y no lo haremos por algún tiempo.

El último tipo de métodos que veremos son los de formato visual. El primero es, center, suma espacios al comienzo y final para hacer que esté centrado. Sin embargo, sólo tienes que decir puts a lo que quieres imprimir, y + a lo que quieres sumar, pero tienes que decir a center que ancho tiene que tener el string centrado. Entonces si quiero centrar las lineas de un poema, debería hacer algo como esto:

Código:

lineWidth = 50
puts(                'Old Mother Hubbard'.center(lineWidth))
puts(               'Sat in her cupboard'.center(lineWidth))
puts(         'Eating her curds an whey,'.center(lineWidth))
puts(          'When along came a spider'.center(lineWidth))
puts(         'Which sat down beside her'.center(lineWidth))
puts('And scared her poor shoe dog away.'.center(lineWidth))

Resultado:

          Old Mother Hubbard
         Sat in her cupboard
      Eating her curds an whey,
       When along came a spider
      Which sat down beside her
  And scared her poor shoe dog away.

Mmmm.. no pienso que esto es un campamento de verano, pero estoy muy cansado para buscar esto. (Entonces, quise alinear la parte .center lineWidth , entonces puse esos espacios extras antes de los textos. Esto es así sólo porque pienso que es más lindo de esta forma. Los programadores generalmente tienen duros conceptos acerca de que es lindo en un programa, y a menudo confrontan acerca de esto. Cuanto más programes, más lograrás tu propio estilo.) Hablando de ser perezoso a la hora de programar, lo cual no es siempre algo malo en programación. Por ejemplo, fíjate como guardé el ancho del poema en la variable lineWidth? Esto es que si entonces quiero regresar más tarde y hacer el poema más ancho, solo tengo que cambiar la variable al comienzo del programa, antes que en cada línea. Con un poema muy largo, esto podría ahorrarme un montón de tiempo. Este tipo de pereza es realmente una virtud en programación.

Entonces, acerca del centrado... tú te darás cuenta que esto no es muy lindo como podría serlo un procesador de texto. Si realmente quieres un perfecto centrado (y quizás una fuente más linda), entonces deberías ¡sólo usar un procesador de textos!. Ruby es una herramienta maravillosa, pero no la herramienta correcta para cualquier trabajo.

Los otros dos métodos de formato de textos son ljust y rjust, lo cual significan justificado izquierdo y justificado derecho. Estos son similares a center, excepto que ellos rellenan los lados derecho e izquierdo respectivamente. Vamos a verlos en acción:

Código:

lineWidth = 40
str = '--> text <--'
puts str.ljust  lineWidth
puts str.center lineWidth
puts str.rjust  lineWidth
puts str.ljust(lineWidth/2) + str.rjust(lineWidth/2)

Resultado:

--> text <--
              --> text <--
                            --> text <--
--> text <--                --> text <--

Algunas cosas por intentar

• Escribe un programa Jefe Enojado. Este debe preguntar de mala manera qué quieres. Cualquier cosa que consultes, el Jefe Enojado deberá devolverte la consulta de mala forma, y luego despedirte. Por ejemplo, si tu escribes Quiero un aumento., deberá contestartePERO QUE DICES HOMBRE "¿¡¿QUIERES UN AUMENTO."?!? ¡¡ESTAS DESPEDIDO!!
• Entonces aquí hay algo para que puedas jugar un poco más con center, ljust, y rjust: Escribe un programa el cual muestre una Tabla de Contenidos que se parezca a lo siguiente:

Listado:

                Tabla de Contenidos

Capítulo 1:  Números                        página 1
Capítulo 2:  Letras                        página 72
Capítulo 3:  Variables                    página 118

Matemáticas Avanzadas

(Esta sección es totalmente opcional. Asume un conocimiento previo de matemáticas. Si no estás interesado, puedes ir directamente al siguiente capítulo Condicionales sin problemas. Aunque, una rápida vista de esta sección sobre Números aleatorios debería venir bien.)

No hay tantos métodos numéricos como los hay para textos (pienso que aun no los conozco a todos sin recurrir a la ayuda de documentación). Aquí, vamos a mirar el resto de los métodos aritméticos, un generador de números aleatorios, y el objeto Math , con sus métodos trigonométricos y transcendentales.

Más de aritmética

Los otros dos métodos aritméticos son ** (potencia) y % (módulo). Entonces si quieres decir "cinco al cuadrado" en Ruby, deberías escribir algo así 5**2. También puedes usar flotantes para tus exponentes, entonces si quieres una raíz cuadrada de 5, deberías escribir 5**0.5. Los métodos módulo te dan el sobrante después de una división por un número. Entonces, por ejemplo, si divido 7 por 3, obtengo 2 con un remanente de 1. Vamos a ver como es que trabaja en un programa:

Código:

puts 5**2
puts 5**0.5
puts 7/3
puts 7%3
puts 365%7

Resultado:

25
2.23606797749979
2
1
1

De la última línea, aprendimos que un año (no bisiesto) tienen algún número de semanas, más un día. Entonces si tu cumpleaños fue un Martes este año, el próximo año será un Miércoles. Tu también puedes usar flotantes con el método módulo (%). Básicamente, funciona de una manera lógica... pero voy a mostrar un poco más como trabajar con esto.

Hay un último método para mencionar: abs. Éste sólo toma el valor absoluto de un número:

Código:

puts((5-2).abs)
puts((2-5).abs)

Resultado:

3
3

Números aleatorios

Ruby viene con un lindo generador de números aleatorios. El método para obtener un número aleatorio es rand. Si llamas rand , obtendrás un número flotante mayor o igual a 0.0 y menor a1.0. Si le proporcionas a rand un número entero (5 por ejemplo), esto te devolverá un entero mayor o igual a 0 y menor a 5 (entonces son cinco números posibles, de 0 a 4).

Vamos a ver rand en acción.

Código:

puts rand
puts rand
puts rand
puts(rand(100))
puts(rand(100))
puts(rand(100))
puts(rand(1))
puts(rand(1))
puts(rand(1))
puts(rand(99999999999999999999999999999999999999999999999999999999999))
puts('El pronosticador del tiempo dijo que hay '+rand(101).to_s+'% chances de que llueva,')
puts('pero nunca debes confiar en él.')

Resultado:

0.866769322351658
0.155609260113273
0.208355946789083
61
46
92
0
0
0
22982477508131860231954108773887523861600693989518495699862
El pronosticador del tiempo dijo que hay 47% chances de que llueva,
pero nunca debes confiar en él.

Fijate que utilicé rand(101) para obtener números entre 0 y 100, y que el rand(1) siempre devuelve 0. No entender el rango posible de retorno de valores es el error más grande que veo en gente que hace rand; aún programadores profesionales, más aún en productos finalizados que puedes comprar. Incluso tenía un reproductor de CD que si se configuraba en "Reproducción aleatoria," reproducía todas las canciones menos la última ... (Me pregunto ¿qué hubiera pasado si hubiera puesto un CD con sólo una canción en ella?)

Algunas veces querrás que rand retorne el mismo random de números incluso en la misma secuencia en dos diferentes ejecuciones de tu programa. (Por ejemplo, una vez estaba utilizando números generados aleatoriamente para crear un mundo al azar para un juego de computadoras. Encontré un mundo que realmente me gustó, quizás me hubiera gustado jugar de nuevo con éste o enviarlo a un amigo.) Con el fin de hacer esto, tu necesitas configurar la "generación de éste", lo que se puede hacer con srand. Como lo siguiente:

Código:

srand 1776
puts(rand(100))
puts(rand(100))
puts(rand(100))
puts(rand(100))
puts(rand(100))
puts ''
srand 1776
puts(rand(100))
puts(rand(100))
puts(rand(100))
puts(rand(100))
puts(rand(100))

Resultado:

24
35
36
58
70

24
35
36
58
70

Esto hará la misma cosa cada vez que inicies con el mismo número. Si quieres obtener diferentes números (como pasaría si nunca utilizaras srand), entonces sólo llamas a srand 0. Esto inicializa con un número realmente raro, utilizando (además de otras cosas) la hora actual de tu computadora, hasta los milisegundos.

El Objeto Math

Finalmente, vamos a echar un vistazo al objeto Math. Deberíamos ir directamente a este:

Código:

puts(Math::PI)
puts(Math::E)
puts(Math.cos(Math::PI/3))
puts(Math.tan(Math::PI/4))
puts(Math.log(Math::E**2))
puts((1 + Math.sqrt(5))/2)

Resultado:

3.14159265358979
2.71828182845905
0.5
1.0
2.0
1.61803398874989

Como puedes ver, Math tiene todas las cosas que podrías esperar de una calculadora científica decente. Y como siempre, los flotantes están realmente cerca de ser la respuesta correcta.

Fuente: http://rubysur.org