6.1.3  Expresiones de coma flotante

En muchas sentencias del lenguaje de POV-Ray será necesario que especifiques uno o más números de coma flotante. Un número de coma flotante es un número con decimales (tambien llamado número real). Éstos pueden especificarse usando literales, identificadores o funciones que devuelvan valore de coma flotante. Tambien puedes crear complejas expresiones de coma flotante combinando todas las anteriores mediante los distintos operadores disponibles.

Alli donde POV-Ray requiera un valor entero, dejará tambien que especifiques un valor de coma flotante, que truncará a entero. Cuando POV-Ray necesita un valor lógico (booleano), interpreta que cualquier distinto de cero es cierto (true), mientras que cero es falso (false).

Dado que las comparaciones de números de coma flotante están sujetas a errores, POV-Ray acepta valores extremadamente cercanos a cero como si fueran "falso" al hacer operaciones booleanas. Normalmente, los valores cuyo valor absoluto es menor que el valor predefinido epsilon se consideran "falso" para las operaciones lógicas. El valor de epsilon es dependiente del sistema, pero normalmente está alrededor de 1.0-10. Dos valores de coma flotante a y b se consideran iguales si abs(a-b) < epsilon.

La sintasix completa de las expresiones de coma flotante se muestra a continuación, y se detallará en las siguientes subsecciones.

FLOAT:
    NUMERIC_TERM [SIGN NUMERIC_TERM]
SIGN:
    + | -
NUMERIC_TERM:
    NUMERIC_FACTOR [MULT NUMERIC_FACTOR]
MULT:
    * | /
NUMERIC_FACTOR:
    FLOAT_LITERAL        |
    FLOAT_IDENTIFIER     |
    SIGN NUMERIC_FACTOR  |
    FLOAT_FUNCTION       |
    FLOAT_BUILT-IN_IDENT |
    ( FULL_EXPRESSION )  |
    ! NUMERIC_FACTOR
VECTOR DECIMAL_POINT DOT_ITEM FLOAT_LITERAL:
    [DIGIT...] [DECIMAL_POINT] DIGIT... [EXP [SIGN] DIGIT...]
DIGIT:
    0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
DECIMAL_POINT:
    .
EXP:
    e | E
DOT_ITEM:
    x | y | z | t | u | v | red | blue | green | filter |
    transmit | gray
FLOAT_FUNCTION:
    abs( FLOAT ) | acos( FLOAT ) | acosh( FLOAT ) | asc( STRING ) |
    asin( FLOAT ) | asinh( FLOAT ) | atan( FLOAT) | atanh( FLOAT) |
    atan2( FLOAT , FLOAT ) | ceil( FLOAT ) | cos( FLOAT ) | 
    cosh( FLOAT ) | defined(IDENTIFIER ) | degrees( FLOAT ) | 
    dimensions( ARRAY_IDENTIFIER ) |
    dimension_size( ARRAY_IDENTIFIER , FLOAT ) | 
    div( FLOAT , FLOAT ) | exp( FLOAT ) | file_exists( STRING ) |
    floor( FLOAT ) | int( FLOAT ) | ln(Float | log( FLOAT ) |
    max( FLOAT , FLOAT, ... ) | min( FLOAT , FLOAT, ... ) |
    mod( FLOAT , FLOAT ) | pow( FLOAT , FLOAT ) |
    radians( FLOAT ) | rand( FLOAT ) | seed( FLOAT ) |
    select( FLOAT, FLOAT, FLOAT [,FLOAT]) | sin( FLOAT ) |
    sinh( FLOAT ) | sqrt( FLOAT ) | strcmp( STRING , STRING ) |
    strlen( STRING ) | tan( FLOAT ) | tanh( FLOAT ) |
    val( STRING ) | vdot( VECTOR , VECTOR ) | vlength( VECTOR ) | 
    FLOAT_BUILT-IN_IDENT:
    clock | clock_delta | clock_on | false | final_clock |
    final_frame | frame_number | initial_clock | initial_frame |
    image_width | image_height | no | off | on | pi | true |
    version | yes |
FULL_EXPRESSION:
    LOGICAL_EXPRESSION [? FULL_EXPRESSION : FULL_EXPRESSION]
LOGICAL_EXPRESSION:
    REL_TERM [LOGICAL_OPERATOR REL_TERM]
LOGICAL_OPERATOR:
    & | | (nota: esto significa que un ampersand o una barra vertical con operadores lógicos)
REL_TERM:
    FLOAT [REL_OPERATOR FLOAT]
REL_OPERATOR:
    < | <= | = | >= | > | !=
INT:
    FLOAT (observa que cualquier sintaxis que requiera un entero INT aceptará también
               un valor de coma flotante FLOAT que será truncado a entero por POV-Ray).

Nota: Los identificadores FLOAT_IDENTIFIERS deben haber sido declarados previamente con valores de coma flotante. La sintaxis DOT_ITEM es realmente un vector o operador de color, pero devuelve un valor de coma flotante. Véase "Operadores de Vectores" o "Operadores de color" para más detalles. Un ARRAY_IDENTIFIER es sólo el nombre del identificador de una matriz previamente declarada, no contiene los corchetes [] ni el índice. La sintaxis de la cadena STRING se describe en la seccion "Cadenas".

6.1.3.1  Literales de coma flotante

Los literales de coma flotante se representan con un signo opcional ("+" o "-"), un punto decimal opcional y digitos decimales también opcionales. Si el número es un entero, puedes omitir el punto decimal y el 0. Si es totalmente una fracción puedes omitir el 0 a la izquierda. POV-Ray soporta la notación científica para números muy grandes o muy pequeños. Los siguientes son literales de coma flotante válidos:

-2.0 -4 34 3.4e6 2e-5 .3 0.6

6.1.3.2  Identificadores de coma flotante

Pueden declararse identificadores de coma flotante para hacer más legibles y parametrizar las escenas, de manera que cambiando una sola declaración se cambien múltiples valores. Un identificador se declara de la siguiente manera:

FLOAT_DECLARATION:
    #declare IDENTIFIER = EXPRESSION;    |
    #local IDENTIFIER = EXPRESSION;

Donde IDENTIFIER es el nombre del identificador, de hasta 40 caracteres de largo, y EXPRESSION  es cualquier expresión válida que se evalúe como un número de coma flotante.

Nota: debería haber un punto y coma detrás de la expresion en una declaracion de coma flotante. Si se omite, se genera un mensaje de alerta, y algunas macros puede que no funcionen bien. Vease la seccion "#declare frente a #local" para más información.

He aquí algunos ejemplos:

 #declare Count = 0;
 #declare Rows = 5.3;
 #declare Cols = 6.15;
 #declare Number = Rows*Cols;
 #declare Count = Count+1;

Como se ve en el último ejemplo, puedes redeclarar un identificador de coma flotante y usar el valor previamente declarado en la redeclaracion. Hay varios identificadores predefindos por defecto en POV-Ray. Véase la sección "Identificadores de Coma Flotante Predefinidos" para más información.

6.1.3.3  Operadores de coma flotante

Expresiones aritméticas: Se pueden crear expresiones matemáticas básicas con literales, identificadores o funciones de coma flotante, usando los siguientes operadores con el orden de precedencia indicado:

( ) las expresiones entre parentesis se evalúan primero
+A -A !A signos unitarios positivo, negativo y de negación
A*B A/B multiplicación y división
A+B A-B suma y resta

También se pueden crear expresiones lógicas y condicionales. Sin embargo, es obligatorio que éstas se encierren siempre entre paréntesis. Esta restricción, que no es habitual en la mayoria de los lenguajes de programacion, es necesaria debido a que POV-Ray permite mezclar valores de coma flotante y vectores. Sin los paréntesis, se daría un problema de ambigüedad. Los paréntesis no son necesarios para el operador lógico unitario de negacion "!". Los operadores son los siguientes:

Expresiones relacionales: Los operandos son expresiones aritméticas y el resultado es siempre booleano, siendo 1 para "cierto" y 0 para "falso". Todos los operadores relacionales tienen el mismo orden de precedencia.

(A < B) A menor que B
(A <= B) A menor o igual que B
(A = B) A igual a B (realmente abs(A-B)<EPSILON)
(A != B) A distinto de B (realmente abs(A-B)>=EPSILON)
(A >= B) A mayor o igual que B
(A > B) A mayor que B

Expresiones lógicas: Los operandos se convierten a valores booleanos de 0 para "falso" y 1 para "cierto". El resultado es siempre booleano. Todos los operadores lógicos tienen el mismo orden de precedencia.

Nota: éstos no son operadores bit-wise, son operadores lógicos.

(A & B) cierto sólo si A y B son ciertos, falso en cualquier otro caso
(A | B) cierto si A o B son ciertos, o si ambos son ciertos

Expresiones condicionales: El operando C es boolenao, mientras que los operandos A y B son cualquier tipo de expresion. El resultado es del mismo tipo que A y B.

(C ? A : B) si C es cierto devuelve A, sino devuelve B

Asumiendo que los identificadores usados han sido declarados, las siguientes espresiones son ejemplos válidos:

 1+2+3    2*5     1/3     Row*3    Col*5
 (Desplazamiento-5)/2      Esto/Aquello+Otra*Cosa
 ((Esto<Aquello) & (Otra>=Cosa)?Tal:Cual)

Las expresiones se evalúan de izquierda a derecha, siendo evaluados primero los paréntesis más extremos, después los signos unitarios +, - o !, tras ellos las multiplicaciones y divisiones, despues las sumas y restas, luego los relacionales, lógicos y condicionales.

6.1.3.4  Identificadores de coma flotante predefinidos

Hay varios identificadores de coma flotante predefinidos. Puedes usarlos para especificar valores o para crear expresiones, pero no puedes redeclararlos para cambiar sus valores. Son los siguientes:

FLOAT_BUILT-IN_IDENT:
    clock | clock_delta | clock_on | false | final_clock |
    final_frame | frame_number | image_height | image_width |
    initial_clock | initial_frame | no | off | on | pi | true |
    version | yes
6.1.3.4.1  Identificadores de constantes

Son los siguientes:

    false | no | off | on | pi | true | yes 

La mayoría de identificadores predefinidos nunca cambian de valor. Están definidos como si se hubieran incluido en cada escena las siguientes líneas:

  #declare pi = 3.1415926535897932384626;
  #declare true = 1;
  #declare yes = 1;
  #declare on = 1;
  #declare false = 0;
  #declare no = 0;
  #declare off = 0;

El identificador de coma flotante pi es, obviamente, útil en expresiones matemáticas que tengan que ver con círculos. Los identificadores predefinidos on, off, yes,no, true, y false están diseñados para usarse como constantes booleanas.

6.1.3.4.2  Identificadores del reloj (clock)

Son los siguientes:

    clock | clock_delta | clock_on | final_clock | final_frame
    frame_number | initial_clock | initial_frame

Estas palabras reservadas te permiten usar los valores del reloj establecidos en la línea de comandos o en el archivo INI. Representan valores enteros o de coma flotante, leidos de las opciones de animación. No puedes redeclarar estos identificadores.

clock (reloj)
El identificador predefinido clock se usa para controlar las animaciones en POV-Ray. Al contrario que otros paquetes de animación, la acción en las escenas animadas con POV-Ray no depende del número (entero) de fotogramas. Debes diseñar tus escenas basándote en el valor de coma flotante clock. Para escenas fijas, de un solo fotograma, el valor por defecto es 0, pero puedes cambiarlo a cualquier valor de coma flotante usando la opcion Clock=n.n en el archivo INI, o el interruptor +Kn.n en la línea de comandos.

Se pueden usar otras opciones INI e interruptores para animar escenas, haciendo bucles automáticos durante el renderizado de los fotogramas, usando diferentes valores del reloj. Por defecto, el valor del reloj es 0 para el fotograma inicial y 1 para el fotograma final. Para el resto de fotogramas se interpola entre estos dos valores.

Por ejemplo, si tu objeto debe rotar un giro completo durante el transcurso de la animación, podrias especificar rotate 360*clock*y. Así, tal como el reloj va desde 0 hasta 1, el objeto rotará alrededor del eje y de 0 a 360 grados.

Aunque el valor de clock cambia de fotograma a fotograma, nunca cambia durante el análisis de la escena.

clock_delta
Este identificador de coma flotante predefinido devuelve la cantidad de tiempo entre dos valores del reloj en las animaciones de POV-Ray. Aunque la mayoría de las animaciones sólo necesitan el valor del reloj, algunos cálculos de animación son más fáciles de diseñar si conoces el tiempo que ha pasado desde el último fotograma. Al diseñar este tipo de escenas ha de tenerse mucha precaucion, ya que si renderizas la escena con muy pocos fotogramas, los resultados pueden ser diferentes de si utilizas más fotogramas en el mismo periodo de tiempo. En escenas fijas, no animadas, el valor por defecto de  clock_delta es 1.0. Vease la sección "Opciones de Animación" para más información.

clock_on
Este identificador sirve para comporbar el estado del reloj: 1=activado, 0=desactivado.

  #if(clock_on=0)
    //instrucciones para imagen fija
  #else
    //instrucciones para la animación
  #end

frame_number
Si prefieres describir la acción basándote en números enteros de fotograma, puedes usar este identificador para realizar tus cálculos. Devuelve el número de fotograma que está siendo renderizado.

  #if(frame_number=1)
    //instrucciones específicas para el primer fotograma
  #end
  #if(frame_number=2)
    //instrucciones para el segundo fotograma
  #end
  #if(frame_number=n)
    //instrucciones para el fotograma n
  #end

initial_clock
Este identificador lee el valor inicial del reloj que se asignó mediante la opcion INI Initial_Clock=n.n o el interruptor +KIn.n.

final_clock
Este identificador lee el valor final del reloj asignado mediante la opcion INI Final_Clock=n.n o el interruptor +KFn.n.

initial_frame
Este identificador lee el valor de fotograma inicial asignado mendiante la opcion INI Initial_Frame=n o el interruptor +KFIn.

final_frame
Este identificador lee el valor de fotograma final asignado mediante la opcion INI Final_Frame=n o el interruptor +KFFn.

Nota: Observa que estos valores son los únicos que se usan realmente. Cuando se especifica la opción de animación cíclica 'cyclic animation', puede que sean diferentes de los originalmente establecidos con las opciones INI o interruptores.

6.1.3.4.3  Identificadores de tamaño de imagen

Son los siguientes:

     image_width | image_height

image_width
Este identificador devuelve el valor de anchura de imagen establecido mediante la opcion INI Width=n o el interruptor +Wn.

image_height
Este identificador devuelve el valor de altura de imagen establecido mediante la opcion INI Height=n o el interruptor +Hn.

Puedes usar estos identificadores predefinidos para ajustar el ratio de aspecto de la cámara correctamente (vectores up y right). El ángulo de visión de la cámara cubre la anchura total de la imagen renderizada. El ratio de aspecto de la cámara siempre sigue la relación entre la anchura y la altura, independientemente del tamaño de la imagen. Puedes usar algo parecido al siguiente código:

  up y*image_height
  right x*image_width

También puedes hacer que algunos ítems de la escena dependan del tamaño de la imagen:

  
  #if (image_width < 300) crand 0.1 #else crand 0.5 #end

o:

  image_map {
    pattern image_width, image_width {  // hacer que la resolucion del patrón
      gradient x                        // dependa del ancho de la imagen final
      color_map { [ 0.0 ... ] [ 1.0 ... ] }
    }
  }
6.1.3.4.4  Identificador de la versión

El identificador predefinido de coma flotante version devuelve el ajuste actual de la opción de compatibilidad de la versión. Aunque este valor es por defecto la versión actual de POV-Ray, puede que se haya cambiado mediante la opcion INI Version=n.n o el interruptor +MVn.n en línea de comando. Esto se usa para indicar a POV-Ray que debe analizar la escena usando la sintaxis de una versión más antigua.

La opcion INI o el interruptor sólo afectará al ajuste inicial. Al contrario que con otros identificadores predefinidos, en este caso sí puedes cambiar el valor de la versión desde una escena. Sin embargo, no se usa #declare para cambiarla, sino la directiva #version. Puedes cambiar la versión del lenguaje cuantas veces desees dentro de una escena.

Junto con el identificador predefinido version, la directiva #version te permite guardar y restaurar los valores previos de este ajuste de compatibilidad. La nueva directiva de identificadores #local es especialmente útil en esto. Por ejemplo, supón que el archivo mystuff.inc tiene sintaxis de la versión 1. Al principio del fichero podrías poner lo siguiente:

 #local Temp_Vers = version;  // guardar valor previo
 #version 1.0;                // cambiar a versión 1.0
 ...                          // instrucciones de la versión 1...
 #version Temp_Vers;          // restaurar versión previa

Nota: es obligatorio poner un punto y coma tras la expresion de coma flotante en la directiva #version. Si se omite se recibe un aviso, y algunas macros pueden no funcionar correctamente.

6.1.3.5  Palabras reservadas booleanas

Los identificadores de coma flotante predefinidos on, off, yes, no, true, y false se usan principalmente como valores booleanos con los modificadores de objeto o parámetros como sturm, hollow, hierarchy, smooth, media_attenuation, y media_interaction. En cualquier sintaxis del tipo keyword [Bool], si especificas solamente la palabra reservada keyword sin el booleano opcional, se asumirá keyword on. No necesitas utilizar el valor boleano, pero es conveniente en favor de la legibilidad. Para desactivarla deberías usar alguno de los booleanos de valor falso o una expresión que se evalúe a 0.

Nota: algunas de estas palabras reservadas están activadas por defecto, si no se especifican.

Por ejemplo:

  object { MyBlob }                // Por defecto, sturm está desactivado y hierarchy está activado
  object { MyBlob sturm }          // activa sturm 
  object { MyBlob sturm on }       // esto también activa sturm 
  object { MyBlob sturm off }      // desactiva sturm
  object { MyBlob hierarchy }      // no hace nada: hierarchy ya estaba activado
  object { MyBlob hierarchy off }  // desactiva hierarchy

6.1.3.6  Funciones de coma flotante

POV-Ray define una variedad de funciones predefinidas para manipular valores de coma flotante, vectores y cadenas. Las llamadas a la función consisten en una palabra reservada para especificar el nombre de la función, seguida de una lista de parámetros encerrados entre paréntesis. Los parámetros están separados por comas. Por ejemplo:

 keyword(param1,param2)

Las siguientes son las funciones que devuelven valores de coma flotante. Toman como parámetros uno o más valores de coma flotante, enteros, vectores o cadenas. Asume que A y B son cualesquiera expresiones válidas que se evalúan como un número de coma flotante; I es un valor de coma flotante que se trunca a entero internamente; S, S1, S2 etc. son cadenas; y V, V1, V2 etc. son expresiones de vectores. El objeto O se supone previamente declarado.

abs(A) Valor absoluto de A. Si A es negativo, devuelve -A, en cualquier otro caso devuelve A.

acos(A) Arco-coseno de A. Devuelve el ángulo, medido en radianes, cuyo coseno es  A.

acosh(A) Coseno inverso hiperbólico de A.

asc(S) Devuelve un entero en el rango 0-255 correspondiente al valor ASCII del primer carácter de la cadena S. Por ejemplo, asc("ABC") es 65, ya que éste es el valor del carácter "A".

asin(A) Arco-seno de A.Devuelve el ángulo, medido en radianes, cuyo seno es  A.

asinh(A) Seno inverso hiperbólico de A.

atan2(A,B) Arco-tangente de (A/B). Devuelve el ángulo, medido en radianes, cuya tangente es (A/B). Devuelve valores apropiados incluso si B es cero. Usa atan2(A,1) para calcular la tangente clásica atan(A) .

atanh(A) Tangente inversa hiperbólica de A

ceil(A) Techo de A. Devuelve el entero más pequeño mayor que A. Redondea al siguiente entero mayor.

cos(A) Coseno de A. Devuelve el coseno del ángulo A, donde A se expresa en radianes.

cosh(A) Coseno hiperbólico de A.

defined(IDENTIFICADOR) Devuelve cierto (true) si el identificador está actualmente definido, falso (false) en caso contrario. Esta función es especialmente útil para detectar el fin de fichero después de una directiva #read, ya que el identificador del archivo se destruye automáticamente cuando se llega al final del archivo. Véase la sección "La Directiva #read" para más informacion.

degrees(A) Convierte radianes a grados. Devuelve el ángulo medido en grados cuyo valor en radianes es A. La fórmula es grados=A/pi*180.0.

dimensions( IDENTIFICADOR_DE_MATRIZ ) Devuelve el número de dimensiones de una matriz previamente declarada. Por ejemplo, si declaras MyArray=array[6][10], entonces dimensions(MyArray) devuelve el valor 2.

dimension_size( IDENTIFICADOR_DE_MATRIZ, VALOR_DE_COMA_FLOTANTE ) Devuelve el tamaño de una dimensión dada, para una matriz previamente declarada. Las dimensiones se numeran de izquierda a derecha, empezando por 1. Por ejemplo, si declaras MyArray=array[6][10], entonces dimension_size(MyArray,2) devuelve el valor 10.

div(A,B) División entera. Devuelve la parte entera de (A/B).

exp(A) Exponente de A. Devuelve el valor de elevar e a la potencia A, donde e es la base del algoritmo natural, esto es, un valor periódico aproximadamente igual a 2.71828182846.

file_exists(S) Intenta abrir un archivo especificado por la cadena S, buscándolo en el directorio actual y las trayectorias de librerias especificadas por las opciones Library_Path o +L. Véase la seccion "Trayectorias de librerías" para más información. Devuelve 1 si se pudo abrir el archivo, y 0 en caso contrario.

floor(A) Suelo de A. Devuelve el entero mayor que sea menor que A. Redondea al entero inferior siguiente.

inside(O,V) Devuelve 0.0 cuando el vector V está en el exterior del objeto especificado por el identificador O, o 1.0 si está en el interior del mismo.

Note: inside no acepta identificadores de objetos que no sean sólidos.

int(A) Parte entera de A. Devuelve el valor truncado a la parte entera de A. Redondea hacia cero.

log(A) Logaritmo de A. Devuelve el logaritmo de base 10 del valor A.

ln(A) Logaritmo natural de A. Devuelve el logaritmo natural de base e del valor A.

max(A,B,...) Máximo de dos o más valores de coma flotante. Devuelve el valor del mayor de los parámetros A,B,...

min(A,B,...) Mínimo de dos o más valores de coma flotante. Devuelve el menor de los parámetros.

mod(A,B) Valor la operacion A módulo B. Devuelve el resto de la división entera A/B. La fórmula es mod=((A/B)-int(A/B))*B.

pow(A,B) Potencia. Devuelve el valor de A elevado a la potencia B.

Nota: Si A es negativo y B no es entero, el valor de retorno de la función es indefinido, y puede depender de la plataforma en que fue compilado POV-Ray.

radians(A) Convierte grados a radianes. Devuelve el ángulo en radianes cuyo valor en grados es A. La fórmula es radianes=A*pi/180.0.

rand(I) evuelve el siguiente número pseudoaleatorio de la secuencia especificada por el entero positivo I. Debes usar seed() para inicializar la secuencia aleatoria antes de llamar a la funcion rand(). Los números aleatorios están distribuidos uniformemente, y tienen valores entre 0.0 y 1.0, ambos inclusive. Los números aleatorios generados por secuencias distintas son variables independientes.

seed(I) Inicializa una nueva secuencia de números pseudoaleatorios, con el valor de semilla incial A. Se devuelve un número correspondiente a esta secuencia aleatoria. Se pueden usar tantas secuencias aleatorias distintas como se desee. Véase el siguiente ejemplo:

  #declare R1 = seed(0);
  #declare R2 = seed(12345);
  sphere { <rand(R1), rand(R1), rand(R1)>, rand(R2) }

Utilizar múltiples generadores de números aleatorios es muy útil en situaciones en que se usa rand() para emplzar un grupo de objetos, y más tarde se decide usar rand() en otra parte parte anterior en la escena para otro cometido. Sin asignar una nueva secuencia aleatoria, los objetos posteriores cambiarían de lugar al añadir más llamadas a rand(). Esto puede resultar muy molesto.

select(A, B, C [,D]). Selección. Puede usarse con tres o cuatro parámetros. Esta función compara el primer argumento con cero, y dependiendo del resultado devolverá  B, C o D. Los parámetros A,B,C,D pueden ser valores de coma flotante o funciones.

Cuando se usa con tres parámetros, si  A < 0 devolverá B, sino C (A >= 0).

Cuando se usa con cuatro parámetros, si A < 0 devolverá B. Si A = 0 devolverá C. Si no, devolverá D (A > 0).

Veamos un ejemplo. Si A tiene consecutivamente los valores -2, -1, 0, 1, y 2:

  //    A =  -2 -1 0 1 2
  select (A, -1, 0, 1)     // devuelve  -1 -1 0 1 1 
  select (A, -1, 1)        // devuelve  -1 -1 1 1 1 

sin(A) Seno de A. Devuelve el seno del ángulo A, donde A se mide en radianes.

sinh(A) Seno hiperbólico de A.

strcmp(S1,S2) Compara la cadena S1 con S2. Devuelve 0 si las cadenas son iguales, un número positivo si S1 va después de S2 en la secuencia ASCII, y un número negativo en cualquier otro caso.

strlen(S) Longitud de la cadena S. Devuelve un entero que representa el número de caracteres en la cadena S.

sqrt(A) Raíz cuadrada de A. Devuelve el valor de la raíz cuadrada de A.

tan(A) Tangente de A. Devuelve la tangente del ángulo A, donde A se mide en radianes.

tanh(A) Tangente hiperbólica de A.

val(S) Convierte la cadena S en un número de coma flotante. Devuelve el valor de coma flotante representado por el texto de la cadena S. Por ejemplo, val("123.45") devuelve el valor 123.45.

vdot(V1,V2) Producto escalar de V1 y V2. El valor devuelto es directamente proporcional a la longitud de los dos vectores y el coseno del ángulo que hay entre ellos. La fórmula para el cálculo es vdot=V1.x*V2.x + V1.y*V2.y + V1.z*V2.z. Véase la escena de demostración animada VECT2.POV para ver una ilustración de su comportamiento.

vlength(V) Longitud de V. Devuelve un valor de coma flotante que es la longitud del vector V. La fórmula es vlength=sqrt(vdot(A,A)). Puede usarse para calcular la distancia entre dos puntos: Dist=vlength(V2-V1).

Vease las secciones "Funciones de vectores" y "Funciones de cadenas" para conocer otras funciones relacionadas con valores de coma flotante, pero que devuelven vectores o cadenas. Ademas de usar las funciones predefinidas aquí descritas, puedes también definir tus propias funciones con la directiva #macro. Véase la sección "Macros definidas por el usuario" para más información.