Make your own free website on Tripod.com
3. Listado alfabético de todas las rutinas

 

?

Sintaxis: ? x
Descripción:
Es la forma abreviada de: pretty_print(1, x, {}) - es decir, de imprimir el valor de una expresión en la salida estándar, con llaves y sangría para mostrar la estructura.
Ejemplo:
? {1, 2} + {3, 4}  -- mostrará {4, 6}

Ver también: pretty_print, print

abort

Sintaxis: abort(i)
Descripción:
Aborta la ejecución de un programa. El argumento 'i' es un entero pequeño para devolver el estado al sistema operativo. Un valor 0 generalmente indica la terminación exitosa del programa. Otros valores pueden indicar distintos tipos de errores. Los programas por lotes DOS (.bat) pueden leer este valor usando la función errorlevel. Un programa Euphoria puede leer este valor usando system_exec().
Comentarios:
abort() es útil cuando un programa está ejecutando llamadas subrutinas anidadas y es necesario terminar la ejecución inmediatamente, tal vez debido a la detección de un error severo.

Si no se usa abort(), ex.exe/exw.exe/exu terminarán devolviendo normalmente el código de estado 0. Si el programa falla debido a un error en tiempo de compilación o ejecución detectado por Euphoria, entonces el código de estado de terminación será 1.

Ejemplo:
if x = 0 then
    puts(ERR, "No se puede dividir por 0 !!!\n")
    abort(1)
else
    z = y / x
end if

Ver también: crash_message, system_exec

all_palette

Plataforma: DOS32
Sintaxis: include graphics.e
all_palette(s)
Descripción:
Especifica nuevas intensidades de color para un conjunto entero de colores en el modo gráfico en uso. 's' es una secuencia de la forma:

{{r,g,b}, {r,g,b}, ..., {r,g,b}}*

Cada elemento especifica una nueva intensidad de color {red, green, blue}* para el número de color correspondiente, comenzando por el número de color 0. Los valores para rojo, verde y azul tienen que estar dentro del rango 0 a 63.

* La terna {r,g,b}={red, green, blue} tal como se la conoce en inglés es {rojo, verde, azul} en español.

Comentarios:
Esta rutina se ejecuta mucho más rápido que si se usa palette() para establecer las nuevas intensidades de los colores uno por uno. Este procedimiento se puede usar con read_bitmap() para mostrar rápidamente una imagen en pantalla.
Programa de ejemplo: demo\dos32\bitmap.ex
Ver también: get_all_palette, palette, read_bitmap, video_config, graphics_mode

allocate

Sintaxis: include machine.e
a = allocate(i)
Descripción:
Asigna 'i' bytes contiguos de memoria. Devuelve la dirección del bloque de memoria, o devuelve 0 si no la pudo asignar. La dirección devuelta será de al menos 4 bytes alineados.
Comentarios:
Al terminar de usar el bloque, debería pasar su dirección a free(). Esta función liberará el bloque y dejará la memoria disponible para otros usos. Euphoria no liberará o reusará su bloque hasta que se llame explícitamente a free(). Cuando termina su programa, el sistema operativo reclamará toda la memoria para usarla con otros programas.
Ejemplo:
buffer = allocate(100)
for i = 0 to 99 do
    poke(buffer+i, 0)
end for

Ver también: free, allocate_low, peek, poke, call

allocate_low

Plataforma: DOS32
Sintaxis: include machine.e
i2 = allocate_low(i1)
Descripción:
Asigna 'i1' bytes contiguos de memoria baja, es decir memoria convencional (direcciones por debajo de 1 Mb). Devuelve la dirección del bloque de memoria, o devuelve 0 si no la pudo asignar.
Comentarios:
Algunas interrupciones de software de DOS requieren que les pase una o más direcciones en registros. Esas direcciones tienen que estar dentro de las direcciones de la memoria convencional para que DOS sea capaz de leerlas o escribir en ellas.
Programa de ejemplo: demo\dos32\dosint.ex
Ver también: dos_interrupt, free_low, allocate, peek, poke

allocate_string

Sintaxis: include machine.e
a = allocate_string(s)
Descripción:
Asigna espacio para una secuencia de cadena 's'. Copia 's' dentro de este espacio, junto con el caracter 0 de terminación. Este es el formato esperado por las cadenas de C. Se devuelve la dirección de memoria de la cadena. Si no hay suficiente memoria disponible, se devuelve 0.
Comentarios: Para liberar la cadena, use free().
Ejemplo:
atom titulo

titulo = allocate_string("El Mago de Oz")
Programa de ejemplo: demo\win32\window.exw
Ver también: allocate, free

allow_break

Sintaxis: include file.e
allow_break(i)
Descripción:
Cuando 'i' valga 1 (verdadero), Ctrl+C y Ctrl+Break pueden terminar el programa, cuando intenta leer la entrada desde el teclado. Si 'i' vale 0 (falso), no se podrá terminar el programa con Ctrl+C o Ctrl+Break.
Comentarios:
El DOS mostrará ^C en pantalla, aún cuando no se pueda terminar el programa.

Inicialmente, el programa se puede terminar el programa en cualquier punto, donde intente leer una entrada desde el teclado. También podría terminarse mediante otra operación de E/S, dependiendo de las opciones que el usuario haya establecido en el archivo config.sys. (Consultar el manual de MS-DOS para el caso del comando BREAK). En algunos programas, esta terminación abrupta podría dejar cosas en un estado desordenado que podría provocar la pérdida de datos. allow_break(0) le permite evitar esta situación.

Se puede saber si el usuario presionó Ctrl+C o Ctrl+Break, llamando a check_break().

Ejemplo:
allow_break(0)  -- no permita que el usuario me aniquile!

Ver también: check_break

and_bits

Sintaxis: x3 = and_bits(x1, x2)
Descripción:
Ejecuta la operación lógica AND sobre los bits correspondientes en 'x1' y 'x2'. El bit en 'x3' será 1 solamente si los bits correspondientes en 'x1' y 'x2' son ambos 1.
Comentarios:
Los argumentos de esta función pueden ser átomos o secuencias. Se aplican las reglas para operaciones sobre secuencias.

Los argumentos se tienen que poder representar como números de 32 bits, sean con o sin signo.

Si intenta manipular valores de 32 bits completos, debería declarar sus variables como átomos, en lugar de enteros. El tipo entero de Euphoria está limitado a 31 bits.

Los resultados se tratan como números con signo. Serán negativos cuando el bit de mayor orden sea 1.

Para comprender la representación binaria de un número debería mostrarlo en notación hexadecimal. Para ello, use el formato %x de printf().

Ejemplo 1:
a = and_bits(#0F0F0000, #12345678)
-- a es #02040000
Ejemplo 2:
a = and_bits(#FF, {#123456, #876543, #2211})
-- a es {#56, #43, #11}

Ejemplo 3:
a = and_bits(#FFFFFFFF, #FFFFFFFF)
-- a es -1
-- Observe que #FFFFFFFF es un número positivo,
-- pero el resultado en una operación lógica bit a bit se interpreta
-- como un número con signo de 32 bits, por lo tanto es negativo.
Ver también: or_bits, xor_bits, not_bits, int_to_bits

append

Sintaxis: s2 = append(s1, x)
Descripción:
Crea una nueva secuencia idéntica a 's1', pero con 'x' agregado al final como último elemento. La longitud de 's2' será length(s1) + 1.
Comentarios: Si 'x' es un átomo, esto es equivalente a s2 = s1 & x, si 'x' es una secuencia, no.

El almacenamiento adicional se asigna automáticamente y en forma muy eficiente, debido a la asignación dinámica de memoria de Euphoria. El caso donde 's1' y 's2' son la misma variable (como en el Ejemplo 1) está altamente optimizado.

Ejemplo 1: Puede usar append() para hacer crecer una secuencia dinámicamente, por ejemplo:
sequence x

x = {}
for i = 1 to 10 do
    x = append(x, i)
end for
-- x ahora es {1,2,3,4,5,6,7,8,9,10}
Ejemplo 2: Se puede agregar cualquier tipo de objeto de Euphoria a una secuencia, por ejemplo:
sequence x, y, z

x = {"juan", "pedro"}
y = append(x, "maría")
-- y ahora es {"juan", "pedro", "maría"}

z = append(append(y, "laura"), {"bum", "bum"})
-- z ahora es {"juan", "pedro", "maría", "laura", {"bum", "bum"}}
Ver también: prepend, concatenation operator &, sequence-formation operator

arccos

Sintaxis: include misc.e
x2 = arccos(x1)
Descripción: Devuelve un ángulo cuyo coseno es igual a 'x1'.
Comentarios: El argumento 'x1' tiene que estar en el rango -1 a +1 inclusive.

Se devolverá un valor entre 0 y PI radianes.

Esta función se puede aplicar a un átomo o a todos los elementos de una secuencia.

arccos() no es tan rápido como arctan().

Ejemplo:
s = arccos({-1,0,1})
-- s es {3.141592654, 1.570796327, 0}

Ver también: cos, arcsin, arctan

arcsin

Sintaxis: include misc.e
x2 = arcsin(x1)
Descripción: Devuelve un ángulo cuyo seno es igual a 'x1'.
Comentarios: El argumento 'x1' tiene que estar en el rango -1 a +1 inclusive.

Se devolverá un valor entre -PI/2 y +PI/2 (radianes).

Esta función se puede aplicar a un átomo o a todos los elementos de una secuencia.

arcsin() no es tan rápido como arctan().

Ejemplo:
s = arcsin({-1,0,1})
-- s es {-1.570796327, 0, 1.570796327}
Ver también: sin, arccos, arctan

arctan

Sintaxis: x2 = arctan(x1)
Descripción: Devuelve un ángulo cuyo tangente es igual a 'x1'.
Comentarios: Se devolverá un valor entre -PI/2 y +PI/2 (radianes).

Esta función se puede aplicar a un átomo o a todos los elementos de una secuencia.

arctan() es más rápida que arcsin() o arccos().

Ejemplo:
s = arctan({1,2,3})
-- s es {0.785398, 1.10715, 1.24905}

Ver también: tan, arcsin, arccos

atom

Sintaxis: i = atom(x)
Descripción: Devuelve 1 si 'x' es un átomo, 0 en caso contrario.
Comentarios:
Sirve para definir el tipo átomo. También puede llamarla como una función ordinaria para determinar si un objeto es un átomo.
Ejemplo 1:
atom a
a = 5.99

Ejemplo 2:
object line

line = gets(0)
if atom(line) then
    puts(SCREEN, "fin del archivo\n")
end if
Ver también: sequence, object, integer, atoms and sequences

atom_to_float32

Sintaxis: include machine.e
s = atom_to_float32(a1)
Descripción:
Convierte un átomo de Euphoria en una secuencia de 4 valores de un byte. Esos 4 bytes contienen la representación de un número de punto flotante IEEE en formato de 32 bits.
Comentarios:
Los átomos de Euphoria puden tener valores que son números de punto flotante IEEE de 64 bits, por lo tanto puede perder precisión al convertirlos a 32 bits (16 dígitos significativos contra 7). El rango del exponente es mucho más grande en el formato de 64 bits (10e308, contra 10e38), por lo que algunos átomos pueden ser demasiado grandes o demasiado pequeños para representarlos en 32 bits. En este caso, obtendrá uno de los valores especiales de 32 bits: inf o -inf (infinito o -infinito). Para evitar esto, puede usar atom_to_float64().

Los valores enteros se convertirán también al formato de punto flotante de 32 bits.

Ejemplo:
fn = open("numeros.dat", "wb")
puts(fn, atom_to_float32(157.82)) -- escribe 4 bytes a un archivo
Ver también: atom_to_float64, float32_to_atom

atom_to_float64

Sintaxis: include machine.e
s = atom_to_float64(a1)
Descripción:
Convierte un átomo de Euphoria en una secuencia de 8 valores de un byte. Esos 8 bytes contienen la representación de un número de punto flotante IEEE en formato de 64 bits.
Comentarios:
Todos los átomos Euphoria tiene valores que se pueden representar como números IEEE de punto flotante de 64 bits, por lo que puede convertir cualquier átomo al formato de 64 bits sin perder precisión.

Los valores enteros se convertirán también al formato de punto flotante de 64 bits.

Ejemplo:
fn = open("numeros.dat", "wb")
puts(fn, atom_to_float64(157.82)) -- escribe 8 bytes a un archivo
Ver también: atom_to_float32, float64_to_atom

bits_to_int

Sintaxis: include machine.e
a = bits_to_int(s)
Descripción:
Convierte una secuencia de valores binarios (1 y 0) a un número positivo. El bit menos significativo es s[1].
Comentarios:
Si imprime 's', los bits aparecerán en orden inverso, pero es conveniente para tener índices crecientes que le den acceso a los bits en orden ascendente de significación.
Ejemplo:
a = bits_to_int({1,1,1,0,1})
-- a es 23 (binario 10111)
Ver también: int_to_bits, operations on sequences

bk_color

Sintaxis: include graphics.e
bk_color(i)
Descripción:
Establece el color de fondo a uno de los 16 colores estándares. En los modos gráficos de píxel la pantalla entera se afectará inmediatamente. En los modos de texto cualquier nuevo caracter que imprima tendrá el nuevo color de fondo.
Comentarios: Los 16 colores estándares están definidos en graphics.e

En los modos gráficos de píxel, el color 0 que normalmente es NEGRO, será establecido al mismo valor {r,g,b}de paleta que el número de color 'i'.

En algunos modos gráficos de píxel, hay un color de borde que aparece en los extremos de la pantalla. En los modos de 256 colores, este es el 17º color en la paleta. Puede controlarlo como lo hace con cualquier otro color.

En los modos de texto, para recuperar el color de fondo original cuando termina su programa, por ejemplo 0 - NEGRO, tiene que llamar a bk_color(0). Si el cursor está en la última línea de la pantalla, tiene que imprimir algo antes de terminar su programa. Un '\n' puede ser suficiente.

Ejemplo:
bk_color(BLACK)

Ver también: text_color, palette

bytes_to_int

Sintaxis: include machine.e
a = bytes_to_int(s)
Descripción:
Convierte una secuencia de 4 elementos de valores byte en un átomo. Los elementos de 's' están en el orden esperado por un entero de 32 bits en el 386+, es decir, el byte menos significativo primero.
Comentarios:
El resultado podría ser mayor que lo que permite el tipo entero, por eso tiene que asignarlo a un átomo.

's' normalmente podría contener valores positivos que se pueden haber leido usando peek() desde 4 posiciones consecutivas de memoria.

Ejemplo:
atom int32

int32 = bytes_to_int({37,1,0,0})
-- int32 es 37 + 256*1 = 293
Ver también: int_to_bytes, bits_to_int, peek, peek4s, peek4u, poke

 

... continua
 
A a B   |   C a D   |   E a G   |   H a O   |   P a R   |   S a T   |   U a Z