|
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".
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
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.
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.
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
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.
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 +K
n.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 +KI
n.n.
final_clock
Este identificador lee el valor final del reloj asignado mediante la
opcion INI Final_Clock=
n.n o el interruptor +KF
n.n.
initial_frame
Este identificador lee el valor de fotograma inicial asignado mendiante
la opcion INI Initial_Frame=
n o el interruptor +KFI
n.
final_frame
Este identificador lee el valor de fotograma final asignado mediante la
opcion INI Final_Frame=
n o el interruptor +KFF
n.
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.
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 +W
n.
image_height
Este identificador devuelve el valor de altura de imagen establecido
mediante la opcion INI Height=
n o el interruptor +H
n.
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 ... ] } } }
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 +MV
n.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.
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
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.
|