ARITMÉTICA

La aritmética se puede dividir en algunos predicados enteros de propósito

especial y una serie de predicados generales para enteros, coma flotante y
aritmética racional, según corresponda. Los predicados aritméticos
generales manejan todas las expresiones. Una expresión es un número
simple o una función. Los argumentos de una función son expresiones. Las
funciones se describen en la sección 4.27.2.3 .

4.27.1 Aritmética de enteros de propósito especial

Los predicados en esta sección proporcionan más operaciones lógicas entre

enteros. No están cubiertos por el estándar ISO, aunque son 'parte de la
comunidad' y se encuentran como biblioteca o integrados en muchos otros
sistemas Prolog.

between(+Low, +High, ?Value)

LOW y HIGH son enteros, HIGH > = LOW . Si Value es un número

entero, Low = < Value = < High . Cuando Value es una variable, se une
sucesivamente a todos los enteros
entre Low y High . Si High es inf o infinite 111 between / 3 es verdadero
iff Value > = Low , una característica que es particularmente interesante
para generar enteros a partir de un cierto valor.

succ ( ? Int1,? Int2 )

Verdadero si Int2 = Int1 + 1 e Int1 > = 0 . Al menos uno de los argumentos

debe ser instanciado a un número natural. Este predicado genera el error de
dominio not_less_than_zero si se llama con un entero negativo. Por
ejemplo, succ(X, 0) falla en silencio y succ(X, -1) genera un error de
dominio. 112

plus(?Int1, ?Int2, ?Int3)

Verdadero si Int3 = Int1 + Int2 . Al menos dos de los tres argumentos deben
ser instanciados a enteros.

divmod ( + Dividend, + Divisor, -Quotient, -Remainder )

Este predicado es una abreviatura para calcular tanto el cociente como

el resto de dos enteros en una sola operación. Esto permite explotar el hecho
de que la implementación de bajo nivel para calcular el cociente también
produce el resto. El tiempo confirma que este predicado es casi el doble de
rápido que realizar los pasos de forma
independiente. Semánticamente, divmod / 4 se define a continuación.

divmod(Dividend, Divisor, Quotient, Remainder) :-

Quotient is Dividend div Divisor,
Remainder is Dividend mod Divisor.

Tenga en cuenta que este predicado solo está disponible si SWI-Prolog se

compila con soporte entero ilimitado. Este es el caso de todas las versiones
empaquetadas.

nth_integer_root_and_remainder(+N, +I, -Root, -Remainder)

Verdadero cuando Root ** N + Remainder = I. N y yo debemos ser

enteros. 113 N debe ser uno o más. Si I es negativo
y N es impar , Root y Remainder son negativos, es decir, lo siguiente vale
para I <0 :

% I < 0,
% N mod 2 =\= 0,
nth_integer_root_and_remainder(
N, I, Root, Remainder),
IPos is -I,
nth_integer_root_and_remainder(
N, IPos, RootPos, RemainderPos),
Root =:= -RootPos,
Remainder =:= -RemainderPos.

4.27.2 Aritmética de propósito general

Los predicados aritméticos generales se compilan opcionalmente

(vea set_prolog_flag / 2 y la opción de línea de comando -O ). La aritmética
compilada reduce los requisitos globales de pila y mejora el
rendimiento. Desafortunadamente, la aritmética compilada no se puede
rastrear, por lo que es opcional.

+ Expr1 > + Expr2

 Verdadero si la expresión Expr1 se evalúa en un número mayor
que Expr2 .

[ISO]+ Expr1 < + Expr2

Verdadero si la expresión Expr1 se evalúa en un número menor
que Expr2 .

[ISO]+ Expr1 = < + Expr2

Verdadero si la expresión Expr1 se evalúa como un número menor o
igual a Expr2 .

[ISO]+ Expr1 > = + Expr2

Verdadero si la expresión Expr1 se evalúa como un número mayor o
igual a Expr2 .

[ISO]+ Expr1 = \ = + Expr2

Verdadero si la expresión Expr1 se evalúa como un número no igual
a Expr2 .

[ISO]+ Expr1 =: = + Expr2

Verdadero si la expresión Expr1 se evalúa como un número igual
a Expr2 .

[ISO]-Número es + Expr
Verdadero cuando Número es el valor con el que Expr evalúa. Por lo
general, is / 2 debe usarse con el operando izquierdo no vinculado. Si
se va a probar la igualdad, se debe utilizar =: = / 2 . Por ejemplo:
?- 1 is Falla sin (pi / 2) se evalúa como flotante 1.0, que no se
sin(pi/2). unifica con el entero 1.
?- 1 =:= Tiene éxito como se esperaba.
sin(pi/2).
4.27.2.1 Tipos aritméticos

SWI-Prolog define los siguientes tipos numéricos:

 entero
Si SWI-Prolog se construye utilizando la biblioteca aritmética de
precisión múltiple (GMP) GNU , la aritmética de
 enteros no tiene límites , lo que significa que el tamaño de los enteros
está limitado solo por la memoria disponible. Sin GMP, los enteros
SWI-Prolog son de 64 bits, independientemente del tamaño entero
nativo de la plataforma. El tipo de soporte de enteros se puede
detectar utilizando los indicadores
Prolog limitados , min_integer y max_integer . Como el uso de GMP es
predeterminado, la mayoría de las siguientes descripciones suponen
una aritmética de enteros ilimitados.

Internamente, SWI-Prolog tiene tres representaciones enteras. Los

enteros pequeños (definidos por el indicador
Prolog max_tagged_integer ) se codifican directamente. Los enteros
más grandes se representan como valores de 64 bits en la pila
global. Los enteros que no caben en 64 bits se representan como
estructuras GNU MPZ serializadas en la pila global.

 número racional
Los números racionales ( Q ) son cocientes de dos enteros. La
aritmética racional solo se proporciona si se usa GMP (ver arriba). Los
números racionales actualmente no son compatibles con un tipo
Prolog. Están representados por el término compuesto rdiv(N,M) . Los
números racionales que se devuelven de is / 2 son canónicos , lo que
significa que M es positivo y N y M no tienen divisores comunes. Los
números racionales se introducen en el cálculo utilizando la
función racional / 1 , racionalizar / 1 o rdiv / 2 (división racional). El
uso del mismo functor para la división racional y para representar
números racionales permite pasar números racionales entre los
cálculos, así como también usar formato / 3 para imprimir.

A largo plazo, es probable que los números racionales se conviertan

en atómicos , así como en un subtipo de número . El código de usuario
que crea o inspecciona los rdiv(M,N) no será portátil para futuras
versiones. Los racionales se crean con una de las funciones
mencionadas anteriormente y se inspeccionan con racional / 3 .

 flotador
Los números de coma flotante se representan usando el tipo
C double . En la mayoría de las plataformas actuales, estos son
números de coma flotante IEEE de 64 bits.
Las funciones aritméticas que requieren argumentos enteros aceptan,
además de los enteros, números racionales con denominador (canónico)
'1'. Si el argumento requerido es flotante, el argumento se convierte en
flotante. Tenga en cuenta que la conversión de enteros a números de coma
flotante puede generar una excepción de desbordamiento. En todos los
demás casos, los argumentos se convierten al mismo tipo usando el
siguiente orden.

entero -> número racional -> número de coma flotante

4.27.2.2 Ejemplos de números racionales

El uso de números racionales con enteros ilimitados permite la aritmética de

enteros exactos o de punto fijo bajo suma, resta, multiplicación y
división. Para explotar la aritmética racional, rdiv / 2 se debe utilizar en
lugar de `/ 'y los números de coma flotante se deben convertir a racional
utilizando racional / 1 . Omitir el / 1 racional en flotantes convertirá un
operando racional en flotante y continuará la aritmética usando números de
coma flotante. Aquí hay unos ejemplos.

A es 2 rdiv 6 A = 1 rdiv 3
A es 4 rdiv 3 + 1 A = 7 rdiv 3
A es 4 rdiv 3 + 1.5 A = 2.83333
A es 4 rdiv 3 + racional (1.5) A = 17 rdiv 6

Tenga en cuenta que los flotantes no pueden representar todos los números
decimales exactamente. La función racional / 1 crea un
equivalente exacto del flotante, mientras que racionalizar / 1 crea un
número racional que está dentro del error de redondeo del flotante del
flotante original. Consulte la documentación de estas funciones para obtener
detalles y ejemplos.

Los números racionales se pueden imprimir como números decimales con

precisión arbitraria utilizando la conversión de formato / 3 de coma
flotante:

? - A es 4 rdiv 3 + racional (1.5),

formato ('~ 50f ~ n', [A]).
2.83333333333333333333333333333333333333333333333333

A = 17 rdiv 6
4.27.2.3 Funciones aritméticas

Las funciones aritméticas son términos que son evaluados por los
predicados aritméticos descritos en la sección 4.27.2 . Hay cuatro tipos de
argumentos para las funciones:

Expr Expresión arbitraria, que devuelve un valor de coma

flotante o un entero.
IntExpr Expresión arbitraria que debe evaluar a un entero.
RatExpr Expresión arbitraria que debe evaluar a un número
racional.
FloatExpr Expresión arbitraria que debe evaluar a un punto flotante.

Para los sistemas que usan aritmética de enteros acotados (el valor
predeterminado es ilimitado, consulte la sección 4.27.2.1 para más detalles),
las operaciones de enteros que causarían un desbordamiento se
convertirían automáticamente en aritmética de coma flotante.

SWI-Prolog proporciona muchas extensiones al conjunto de funciones de

coma flotante definidas por el estándar ISO. La política actual es
proporcionar tales funciones según sea necesario si la función es
ampliamente compatible en otros lugares y especialmente si es parte de la
biblioteca matemática C99 . Además, intentamos mantener la compatibilidad
con YAP .

[ISO]- + Expr
Resultado = - Expr
[ISO]+ + Expr
Resultado = Expr . Tenga en cuenta que si + es seguido por un número,
el analizador descarta el + . Es decir ?- integer(+1) tiene éxito.

[ISO]+ Expr1 + + Expr2

Resultado = Expr1 + Expr2
[ISO]+ Expr1 - + Expr2
Resultado = Expr1 - Expr2
[ISO]+ Expr1 * + Expr2
 Resultado = Expr1 × Expr2
[ISO]+ Expr1 / + Expr2
Resultado = Expr1 / Expr2 . Si la iso de la bandera es true , ambos
argumentos se convierten en flotante y el valor de retorno es
flotante. De lo contrario (predeterminado), si ambos argumentos son
enteros, la operación devuelve un entero si la división es exacta. Si al
menos uno de los argumentos es racional y el otro argumento es
entero, la operación devuelve un número racional. En todos los demás
casos, el valor de retorno es flotante. Ver también /// 2 y rdiv / 2 .

[ISO]+ IntExpr1 mod + IntExpr2

Módulo, definido como Resultado = IntExpr1 -
( IntExpr1 div IntExpr2 ) × IntExpr2 , donde div es la división
de pisos .

[ISO]+ IntExpr1 rem + IntExpr2

Resto de la división de enteros. Se comporta como si el resultado
definido es IntExpr1 - ( IntExpr1 // IntExpr2 ) × IntExpr2

[ISO]+ IntExpr1 // + IntExpr2

La división entera, definida
como Resultado es rnd_I ( Expr1 / Expr2 ). La función rnd_I es el
redondeo predeterminado utilizado por el compilador de C y está
disponible a través del indicador
Prolog integer_rounding_function . En el estándar C99, el redondeo en
C se define como hacia towards_zero . 114

[ISO]div ( + IntExpr1, + IntExpr2 )

La división entera, definida como Resultado es
( IntExpr1 - IntExpr1 mod IntExpr2 ) // IntExpr2 . En otras palabras,
esta es una división entera que se redondea hacia el infinito. Esta
función garantiza un comportamiento que es consistente con mod / 2 ,
es decir, lo siguiente se cumple para cada par de enteros X, Y donde Y
=\= 0 .

Q es div (X, Y),

M es mod (X, Y),
X =: = Y * Q + M.
+ RatExpr rdiv + RatExpr
División de números racionales. Esta función solo está disponible si
SWI-Prolog se ha compilado con soporte de números
racionales. Consulte la sección 4.27.2.2 para más detalles.

+ IntExpr1 gcd + IntExpr2

El resultado es el máximo divisor común de IntExpr1 , IntExpr2 .

[ISO]abs ( + Expr )
Evaluar Expr y devolver el valor absoluto de la misma.

Signo [ISO]( + Expr )

Evalúe a -1 si Expr <0 , 1 si Expr > 0 y 0 si Expr = 0 . Si Expr se evalúa
como flotante, el valor de retorno es flotante (p. Ej., -1.0, 0.0 o 1.0). En
particular, tenga en cuenta que el signo (-0.0) se evalúa a 0.0. Ver
también copysign / 2

[ISO]copysign ( + Expr1, + Expr2 )

Evalúe a X , donde el valor absoluto de X es igual al valor absoluto
de Expr1 y el signo de X coincide con el signo de Expr2 . Esta función
se basa en copysign () de C99, que funciona en flotantes de doble
precisión y se ocupa de manejar el signo de valores especiales de
coma flotante como -0.0. Nuestra implementación sigue a C99 si
ambos argumentos son flotantes. De lo contrario, copysign / 2
se evalúa como Expr1 si el signo de ambas expresiones coincide o
- Expr1 si los signos no coinciden. Aquí, usamos la noción extendida de
signos para números de coma flotante, donde el signo de -0.0 y otros
flotadores especiales es negativo.

[ISO]máx. ( + Expr1, + Expr2 )

Evalúe al mayor de Expr1 y Expr2 . Ambos argumentos se comparan
después de convertir al mismo tipo, pero el valor de retorno está en el
tipo original. Por ejemplo, max (2.5, 3) compara los dos valores
después de convertir a flotante, pero devuelve el entero 3.

[ISO]min ( + Expr1, + Expr2 )

Evalúe al menor de Expr1 y Expr2 . Vea max / 2 para una descripción
del manejo de tipos.
. ( + Int, [] )
Una lista de un elemento se evalúa como el elemento. Esto implica
que "a" evalúa el código de caracteres de la letra 'a' (97) utilizando el
mapeo tradicional de la cadena entre comillas dobles a una lista de
códigos de caracteres. La evaluación aritmética también traduce un
objeto de cadena (ver sección 5.2 ) de una longitud de caracteres en el
código de caracteres para ese carácter. Esto implica que la
expresión "a" también funciona con el indicador
Prolog double_quotes está establecida en string . La forma
recomendada para especificar el código de caracteres de la letra 'a'
es 0'a .

aleatorio ( + IntExpr )
Evalúe a un entero aleatorio i para el cual 0 = <i < IntExpr . El sistema
tiene dos implementaciones. Si se compila con soporte para aritmética
ilimitada (predeterminado), utiliza las funciones aleatorias de la
biblioteca GMP. En este caso, cada hilo mantiene su propio estado
aleatorio. El algoritmo predeterminado es el algoritmo Mersenne
Twister . La semilla se establece cuando se genera el primer número
aleatorio en un hilo. Si está disponible, se establece
desde /dev/random . 115 De lo contrario, se configura desde el reloj del
sistema. Si no se admite la aritmética ilimitada, se comparten números
aleatorios entre los subprocesos y la semilla se inicializa desde el reloj
cuando se inicia SWI-Prolog. El predicado set_random / 1 se puede
usar para controlar el generador de números aleatorios.

¡Advertencia! Aunque sembró correctamente (si es compatible con el

sistema operativo), el algoritmo Mersenne Twister no produce
números aleatorios criptográficamente seguros. Para generar
números aleatorios criptográficamente seguros,
use crypto_n_random_bytes / 2 de la biblioteca de
la library(crypto) proporcionada por el paquete ssl .

random_float
Evalúe en un flotante aleatorio I para el cual 0.0 <i <1.0 . Esta función
comparte el estado aleatorio con random / 1 . Todos los comentarios
con la función random / 1 también se aplican para random_float /
0 . Tenga en cuenta que ambos lados del dominio están abiertos . Esto
 evita errores de evaluación en, por ejemplo, log / 1 o // 2, mientras
que ninguna aplicación práctica puede esperar 0.0. 116

[ISO]ronda ( + Expr )
Evalúa Expr y redondea el resultado al entero más cercano. De
acuerdo con ISO, round / 1 se define como floor(Expr+1/2) , es decir,
redondeando hacia abajo . Esta es una opción poco convencional bajo
la cual la relación round(Expr) == -round(-Expr) no se cumple. SWI-
Prolog se redondea hacia afuera , por ejemplo, round(1.5) =:=
2 y round(-1.5) =:= -2 .

entero ( + Expr )
Igual que round / 1 (compatibilidad con versiones anteriores).

Flotador [ISO]( + Expr )

Traduce el resultado a un número de coma flotante. Normalmente,
Prolog usará números enteros siempre que sea posible. Cuando se usa
alrededor del segundo argumento de is / 2 , el resultado se devolverá
como un número de coma flotante. En otros contextos, la operación no
tiene efecto.

racional ( + Expr )
Convierta el Expr en un número racional o entero. La función devuelve
la entrada en enteros y números racionales. Para los números de coma
flotante, el número racional devuelto representa exactamente el
flotante. Como los flotantes no pueden representar exactamente todos
los números decimales, los resultados pueden ser sorprendentes. En
los ejemplos a continuación, los dobles pueden representar 0.25 y el
resultado es el esperado, en contraste con el resultado
de rational(0.1) . La función racionalizar / 1 remedia esto. Consulte
la sección 4.27.2.2 para obtener más información sobre el soporte de
números racionales.

? - A es racional (0.25).

A es 1 rdiv 4
? - A es racional (0.1).
A = 3602879701896397 rdiv 36028797018963968
racionalizar ( + Expr )
 Convierta el Expr en un número racional o entero. La función es
similar a racional / 1 , pero el resultado solo es preciso dentro del
error de redondeo de los números de coma flotante, generalmente
produciendo un denominador mucho más pequeño. 117

? - A es racionalizar (0.25).

A = 1 rdiv 4
? - A es racionalizar (0.1).

A = 1 rdiv 10
[ISO]float_fractional_part ( + Expr )
Parte fraccional de un número de coma flotante. Negativo si Expr es
negativo, racional si Expr es racional y 0 si Expr es entero. La siguiente
relación es siempre cierta: X es float_fractional_part (X) +
float_integer_part (X) .
[ISO]float_integer_part ( + Expr )
Parte entera del número de coma flotante. Negativo si Expr es
negativo, Expr si Expr es entero.

[ISO]truncado ( + Expr )
Truncar Expr a un entero. Si Expr > = 0, esto es lo mismo
que floor(Expr) . Para Expr <0 esto es lo mismo que ceil(Expr) . Es
decir, truncar / 1 redondea hacia cero.

[ISO]piso ( + Expr )
Evalúe Expr y devuelva el entero más grande, más pequeño o igual al
resultado de la evaluación.

Techo [ISO]( + Expr )

Evalúe Expr y devuelva el entero más pequeño más grande o igual al
resultado de la evaluación.

techo ( + Expr )
Igual que techo / 1 (compatibilidad con versiones anteriores).

[ISO]+ IntExpr1 >> + IntExpr2

Bitwise desplaza IntExpr1 por IntExpr2 bits hacia la derecha. La
operación realiza un cambio aritmético , lo que implica que los bits
 más significativos insertados son copias de los bits más significativos
originales.

[ISO]+ IntExpr1 << + IntExpr2

Bitwise desplaza IntExpr1 por IntExpr2 bits hacia la izquierda.

[ISO]+ IntExpr1 \ / + IntExpr2

Bitwise `o ' IntExpr1 e IntExpr2 .

[ISO]+ IntExpr1 / \ + IntExpr2

Bitwise `e ' IntExpr1 e IntExpr2 .

[ISO]+ IntExpr1 xor + IntExpr2

Bitwise `exclusivo o ' IntExpr1 e IntExpr2 .

[ISO]\ + IntExpr
Negación bit a bit. El valor devuelto es el complemento de IntExpr .

[ISO]sqrt ( + Expr )
Resultado = sqrt ( Expr )
[ISO]sin ( + Expr )
Resultado = sin ( Expr ) . Expr es el ángulo en radianes.
[ISO]cos ( + Expr )
Resultado = cos ( Expr ) . Expr es el ángulo en radianes.
[ISO]bronceado ( + Expr )
Resultado = tan ( Expr ) . Expr es el ángulo en radianes.
[ISO]asin ( + Expr )
Resultado = arcsin ( Expr ) . El resultado es el ángulo en radianes.
[ISO]acos ( + Expr )
Resultado = arccos ( Expr ) . El resultado es el ángulo en radianes.
[ISO]atan ( + Expr )
Resultado = arctan ( Expr ) . El resultado es el ángulo en radianes.
[ISO]atan2 ( + YExpr, + XExpr )
Resultado = arctan ( YExpr / XExpr ) . El resultado es el ángulo en
radianes. El valor de retorno está en el rango [- pi ... pi] . Se usa para
convertir entre sistema de coordenadas rectangular y polar.

Tenga en cuenta que el estándar ISO Prolog exige

que atan2(0.0,0.0) un error de evaluación, mientras que los
estándares C99 y POSIX exigen que se evalúe a 0.0. SWI-Prolog sigue a
C99 y POSIX.

atan ( + YExpr, + XExpr )

Igual que atan2 / 2 (compatibilidad con versiones anteriores).

sinh ( + Expr )
Resultado = sinh ( Expr ) . El seno hiperbólico de X se define como e **
X - e ** -X / 2 .
cosh ( + Expr )
Resultado = cosh ( Expr ) . El coseno hiperbólico de X se define
como e ** X + e ** -X / 2 .

tanh ( + Expr )
Resultado = tanh ( Expr ) . La tangente hiperbólica de X se define
como sinh (X) / cosh (X) .

asinh ( + Expr )
Resultado = arcsinh ( Expr ) (seno hiperbólico inverso).
acosh ( + Expr )
Resultado = arccosh ( Expr ) (coseno hiperbólico inverso).
atanh ( + Expr )
Resultado = arctanh ( Expr ) . (tangente hiperbólica inversa).
Registro [ISO]( + Expr )
Logaritmo natural. Resultado = ln ( Expr )

log10 ( + Expr )
 Logaritmo de base 10. Resultado = log10 ( Expr )

[ISO]exp ( + Expr )
Resultado = e ** Expr
[ISO]+ Expr1 ** + Expr2
Resultado = Expr1 ** Expr2 . El resultado es un flotante, a menos que
SWI-Prolog se compile con un soporte entero ilimitado y las entradas
sean enteras y produzcan un resultado entero. Se garantiza que las
expresiones enteras 0 ** I , 1 ** I y -1 ** I funcionan para cualquier
entero I. Otros valores base enteros generan un error de resource si el
resultado no cabe en la memoria.

El estándar ISO exige un resultado flotante para todas las entradas e

introduce ^ / 2 para la exponenciación de enteros. La función float /
1 se puede usar en uno o ambos argumentos para forzar un resultado
de coma flotante. Tenga en cuenta que la conversión del resultado
de entrada en un cálculo de coma flotante, mientras que la conversión
de salida realiza una exponenciación de enteros seguida de una
conversión a flotante.

[ISO]+ Expr1 ^ + Expr2

En SWI-Prolog, ^ / 2 es equivalente a ** / 2 . La versión ISO es similar,
excepto que produce un error de evaluación si Expr1 y Expr2 son
enteros y el resultado no es un entero. La siguiente tabla ilustra el
comportamiento de las funciones de exponenciación en ISO y SWI.

Expr1 Expr2 Función SWI YO ASI

En t En t ** / 2 Int o Float Flotador
En t Flotador ** / 2 Flotador Flotador
Racional En t ** / 2 Racional -
Flotador En t ** / 2 Flotador Flotador
Flotador Flotador ** / 2 Flotador Flotador
En t En t ^/2 Int o Float Int o error
En t Flotador ^/2 Flotador Flotador
Racional En t ^/2 Racional -
Flotador En t ^/2 Flotador Flotador
Flotador Flotador ^/2 Flotador Flotador
powm ( + IntExprBase, + IntExprExp, + IntExprMod )
Resultado = ( IntExprBase ** IntExprExp ) módulo IntExprMod . Solo
está disponible cuando se compila con soporte entero ilimitado. Esta
fórmula es necesaria para el intercambio de claves Diffie-Hellman, una
técnica en la que dos partes pueden establecer una clave secreta a
través de una red pública. IntExprBase e IntExprExp deben ser no
negativos ( > = 0 ), IntExprMod debe ser positivo ( > 0 ). 118

lgamma ( + Expr )
Devuelve el logaritmo natural del valor absoluto de la función
Gamma. 119

erf ( + Expr )
Wikipedia : `` En matemáticas, la función de error (también llamada
función de error de Gauss) es una función especial (no elemental) de
forma sigmoidea que ocurre en probabilidad, estadísticas y
ecuaciones diferenciales parciales ''.

erfc ( + Expr )
Wikipedia : `` La función de error complementaria ''.
[ISO]pi
Evalúe la constante matemática pi (3.14159 ...).
mi
Evalúe la constante matemática e (2.71828 ...).
épsilon
Evalúe la diferencia entre el flotador 1.0 y el primer número de punto
flotante más grande.
inf
Evaluar hasta el infinito positivo. Ver sección 2.17.1.6 . Este valor se
puede negar usando - / 1 .
yaya
Evaluar a No es un número . Ver sección 2.17.1.6 .
cputime
 Evalúe hasta un número de coma flotante que exprese el tiempo
de CPU (en segundos) utilizado por Prolog hasta ahora. Ver
también estadísticas / 2 y tiempo / 1 .

eval ( + Expr )
Evaluar Expr . Aunque el estándar ISO dicta que ' A = 1 + 2, B es A '
funciona y unifica B a 3, se cree ampliamente que las variables de nivel
fuente en expresiones aritméticas deberían haberse limitado a
números. En esta vista, la función eval puede usarse para evaluar
expresiones arbitrarias. 120

Funciones de Bitvector

Las funciones a continuación no están cubiertas por el estándar. La

función msb / 1 también aparece en hProlog y SICStus Prolog. La
función getbit / 2 también aparece en ECLiPSe, que también
proporciona setbit(Vector,Index) y clrbit(Vector,Index) . Las otras son
extensiones SWI-Prolog que mejoran el manejo de enteros --- sin límites ---
como vectores de bits.

msb ( + IntExpr )
Devuelve el entero más grande N tal que (IntExpr >> N) /\ 1 =:=
1 . Este es el índice (de origen cero) del 1 bit más significativo en el
valor de IntExpr , que debe evaluar a un entero positivo. Errores para
0, enteros negativos y no enteros.

lsb ( + IntExpr )
Devuelve el entero más pequeño N tal que (IntExpr >> N) /\ 1 =:=
1 . Este es el índice (de origen cero) del 1 bit menos significativo en el
valor de IntExpr , que debe evaluar a un entero positivo. Errores para
0, enteros negativos y no enteros.

popcount ( + IntExpr )
Devuelve el número de 1s en la representación binaria del entero no
negativo IntExpr .

getbit ( + IntExprV, + IntExprI )

Evalúa el valor de bit (0 o 1) del bit IntExprI -th de IntExprV . Ambos
argumentos deben evaluar a enteros no negativos. El resultado es
equivalente a (IntExprV >> IntExprI)/\1 , pero más eficiente porque se
evita la materialización del valor desplazado. Las versiones futuras
optimizarán (IntExprV >> IntExprI)/\1 a una llamada a getbit / 2 ,
proporcionando portabilidad y rendimiento. 121