Programacin en AutoLISP

ONCE.1. INTRODUCCIN
A parte de todo lo visto en cuestin de personalizacin, AutoCAD 14 ofrece al
usuario la posibilidad de crear programas y aplicaciones verticales totalmente
funcionales. Estos programas podrn ser distribuidos por el creador, eso s, siempre
corrern bajo AutoCAD.
La capacidad para hacer un programa nos lleva mucho ms all de la simple
personalizacin de mens o patrones de sombreado, nos lleva a un mundo
totalmente integrado en AutoCAD desde donde podremos disear nuestros propios
comandos, manipular dibujos o incluso acceder a la Base de Datos interna del
programa.
AutoCAD 14 proporciona diversas interfaces de programacin de aplicaciones que
vamos a comentar ahora de forma somera.

ONCE.1.1. AutoLISP, ADS, ARX, VBA y

Visual Lisp
ONCE.1.1.1. Entorno AutoLISP
Dentro de lo que es la programacin existen diversas interfaces para crear
programas paraAutoCAD. El ms antiguo y, quiz el ms utilizado hasta ahora, es
AutoLISP. AutoLISP es una adaptacin del lenguaje de programacin LISP que
forma parte ntima e integrada con AutoCAD, esto es, AutoCAD posee
internamente un propio intrprete de LISP.
El lenguaje LISP est basado en lo que se denominan listas de smbolos. Es un
lenguaje de alto nivel (como BASIC) y que, en principio, fue diseado para la
investigacin en el campo de la inteligencia artificial. AutoLISP es un lenguaje
evaluado, es decir, est a un paso entre los lenguajes interpretados, por un lado, y
los lenguajes compilados, por otro.
Como hemos dicho, AutoCAD provee al usuario de un propio intrprete de
AutoLISP interno. Este intrprete, al que habra que llamarle evaluador, se encarga
precisamente de evaluar las expresiones incluidas en el cdigo fuente de un
programa. Estos programas pueden introducirse directamente desde la lnea de
comandos de AutoCAD, o bien cargarse en memoria a partir de un programa
completo escrito es un archivo de texto ASCII. Dichos archivos tendrn
habitualmente la extensin .LSP.
De la programacin en AutoLISP hablaremos largo y tendido en este MDULO.

ONCE.1.1.2. Entorno ADS

ADS (AutoCAD Development System) es un entorno de programacin el lenguaje C
paraAutoCAD. Las aplicaciones programadas de esta manera han de ser llamadas
desde un propio programa AutoLISP, ya que AutoCAD las considera como
funciones externas.
El cdigo fuente de estas aplicaciones ha de escribirse y compilarse en un
compilador externo de C, es decir, AutoCAD no provee de un entorno de
programacin para estas aplicaciones, como ocurre con AutoLISP o VBA. El
programa objeto ejecutable .EXE (normalmente), producto de la compilacin del
fuente, podr ser cargado desde AutoCAD.
NOTA: Este entorno est ya obsoleto en la versin 14 y los programas desarrollados
en l debern adaptarse a ARX mediante el entorno ADSRX.

ONCE.1.1.3. Entorno ARX

ARX (AutoCAD Runtime Extension) es desde la versin 13 de AutoCAD otro
entorno de programacin C que posibilita, al contrario que ADS, una comunicacin
directa de las aplicaciones con AutoCAD. De esta forma, no es necesaria la
intervencin de AutoLISP como intermediario. La aplicacin Render, en RENDER.ARX,
es un ejemplo de programa en este formato.
La no integracin de un entorno de programacin en C dentro del software
de AutoCAD ha hecho que su utilizacin para desarrollar aplicaciones para el
programa no est muy extendida. Es necesario, pues, adquirir un compilador de C
complementario para poder desarrollar en este lenguaje aplicaciones ADS o ARX, lo
que no ocurre con AutoLISP o VBA. Por este motivo, tampoco se tratar en este
curso.
NOTA: En la versin 14 de AutoCAD existe el comando ARX para cargar, descargar
y obtener informacin sobre aplicaciones ARX sin necesidad de utilizar AutoLISP.

ONCE.1.1.4. Entorno VBA

VBA (Visual BASIC for Applications) es un novedoso entorno, incluido en la versin
14, que parece hacer furor entre los programadores ltimamente. La programacin
en Visual BASIC para Windows viene siendo, desde hace unos aos, una de las
herramientas ms verstiles y, a la vez, ms sencillas y utilizadas en el mundo de la
programacin informtica. El usuario puede desarrollar sus programas en un
compilador Visual BASIC externo o utilizar el propio mdulo VBA que
incluye AutoCAD 14. Este mdulo contiene la sintaxis del lenguaje, un depurador y
un entorno de desarrollo. As, el programador, puede programar rutinas VBA e ir
probndolas en una sesin de AutoCAD mientras se van depurando.
VBA ser ampliamente tratado en el MDULO DOCE.

ONCE.1.1.5. Entorno Visual Lisp

A partir de la Versin 14 existe un nuevo entorno de desarrollo denominado Visual
Lisp que permite realizar aplicaciones en AutoLISP de una manera ms rpida y
efectiva. Este entorno proporciona herramientas para desarrollar y depurar las
rutinas y compilarlas como aplicaciones ARX. Tambin dispone de su propio
evaluador, que emula al de AutoLISP, adems de un completo control de
codificacin y seguridad de las rutinas creadas.
El entorno de Visual Lisp es un mdulo que se carga bajo demanda. No est
incluido en el propio ncleo de AutoCAD, como ocurre con el evaluador de
AutoLISP. El nuevo conjunto de funciones incorporadas en Visual Lisp permite
trabajar en diferentes reas y niveles que incluyen funciones aadidas de AutoLISP,
funciones de acceso al sistema operativo y E/S de archivos, funciones de carga y
vinculacin de objetos y bases de datos, almacenamiento directo de listas en un
archivo de dibujo, acceso al conjunto de objetos ActiveX de AutoCAD y tecnologa
basada en ObjectARX que no necesita la presencia de AutoCAD para su ejecucin.
De esta manera, el entorno de Visual Lisp permite a los desarrolladores la
programacin en ARX y ActiveX.

ONCE.2. CARACTERSTICAS DE AutoLISP

Como ya hemos dicho, LISP (LISt Processing) es un lenguaje de programacin que
se remonta a los aos cincuenta y que fue desarrollado para la investigacin de
inteligencia artificial. La base de su funcionamiento es el manejo de listas, en lugar
de datos numricos como otros lenguajes. AutoLISP es una implantacin LISP
en AutoCAD.
Una lista es un conjunto de smbolos. El smbolo es la unidad mnima bsica de una
lista, y puede ser una variable, una funcin inherente a AutoLISP, una funcin de
usuario, un dato constante... Las listas elaboradas mediante smbolos son
evaluadas y procesadas para obtener un resultado.
Para programar en AutoCAD, este lenguaje proporciona una serie de posibilidades
como la facilidad para manejar objetos heterogneos (nmeros, caracteres,
funciones, entidades u objetos de dibujo, etctera), la facilidad para la interaccin
en un proceso de dibujo, la sencillez del lenguaje y su sintaxis, y otras que hacen
de l una herramienta muy til y sencilla de manejar y aprender.
Como tambin hemos dicho ya, el lenguaje AutoLISP (y LISP) es un lenguaje
evaluado, y no interpretado o compilado. Los lenguajes interpretados son ledos
palabra a palabra por el ordenador, al ser introducidas, y cada una de ellas
convertida a lenguaje mquina. Esto hace que sea sencilla su edicin y deteccin de
errores de sintaxis u otros; por el contrario, hace que sean muy lentos (ejemplo:
Microsoft QBASIC). Los cdigos de los lenguajes compilados son escritos por
completo y, antes de su ejecucin final, es necesario compilarlos, convirtindolos
as en cdigo fuente ejecutable y comprensible por la mquina. Este tipo de
lenguajes hace que su ejecucin sea ms rpida y pura pero, en contra, resulta
ms difcil su depuracin (ejemplos: Microsoft QuickBASIC o Borland C++).

Los lenguajes evaluados AutoLISP estn a caballo entre unos y otros. No son
tan rpidos como los compilados pero son ms flexibles e interactivos que estos. Es
posible, por ejemplo, construir un programa con AutoLISP que sea capaz de
modificarse a s mismo bajo determinadas circunstancia; sta es la base de los
llamados Sistema Expertos.
El mecanismo evaluador de AutoLISP es la propia lista: conjunto de smbolos
separados entre s por, al menos, un espacio blanco y encerrados entre parntesis.
Esto es, desde el momento que existe una expresin encerrada entre parntesis,
AutoLISP la evala e intenta ofrecer un resultado.
AutoLISP es un subconjunto del lenguaje Common LISP. Como ha sido diseado
para trabajar desde AutoCAD, se han seleccionado las caractersticas de LISP ms
adecuadas para este fin y, adems, se han aadido otras nuevas, sobre todo en la
manipulacin de objetos de dibujo, acceso a la Base de Datos de AutoCAD e
interaccin grfica general.
Los programas en AutoLISP son simples archivos de texto ASCII, con la extensin
habitual .LSP. Una vez hecho el programa, habremos de cargarlo desde el propio
editor de dibujo de AutoCAD. Tambin es posible escribir lneas de cdigo AutoLISP
desde la lnea de comandos del programa, como veremos en breve.
Es posible la creacin de rdenes nuevas que llamen a programas en AutoLISP, as
como la redefinicin de comandos propios de AutoCAD, como por
ejemplo LINEA o DESPLAZA. Pero una de las ms importantes potencialidades de
AutoLISP es el acceso directo a la Base de Datos interna de AutoCAD. Toda la
informacin de un dibujo, como deberamos saber, no se guarda como objetos de
dibujo en s, o sea, cuando salvamos un .DWG, en disco no se guardan los crculos,
lneas, etctera, sino una relacin o base de datos donde se dice dnde aparece un
crculo o una lnea, con qu coordenadas de origen y final, con qu radio o
dimetro, tipo de lnea, color... Podremos pues desde AutoLISP acceder a dicha
base de datos para modificarla, editarla o para exportar datos, por ejemplo, a una
base de datos externa.

ONCE.2.1. Tipos de objetos y datos en

AutoLISP
Atendiendo a sus caractersticas podemos definir varios tipos de objetos y datos en
AutoLISP, que son los de la tabla siguiente:
Objeto o dato ------------------------ Descripcin
------------------------------------------------------------------------------------------------------------

Lista ---------------------------------- Objeto compuesto de un parntesis de aper--------------------------------------- tura, uno o ms elementos separados por, al
--------------------------------------- menos, un espacio en blanco y un parntesis
--------------------------------------- de cierre. Los elementos de una lista pueden
--------------------------------------- ser smbolos, valores concretos (constantes
--------------------------------------- numricas o cadenas) o listas incluidas. Por
--------------------------------------- ejemplo: (DEFUN seno (x) (SETQ xr (* PI
(/x 180.0))) (SETQ

--------------------------------------contiene cinco elemen---------------------------------------------------------------------------------------------------------------------------------------------------------

s (SIN xr))), se trata de una lista que

tos: una funcin inherente de AutoLISP
DEFUN, un nombre de funcin de usuario
seno, una lista con un nico elemento (x) y
dos listas SETQ con tres elementos cada una.

Elemento ----------------------------- Cualquiera de los componentes de una lista.

Smbolo ------------------------------- Cualquier elemento de una lista que no sea
--------------------------------------- una constante. Puede ser el nombre de una
--------------------------------------- variable, un nombre de funcin definida por
--------------------------------------- el usuario o un nombre de funcin de AutoLISP.
Enteros ------------------------------- Valores numricos enteros, sin punto deci--------------------------------------- mal. Internamente son nmeros de 32 bits
--------------------------------------- con signo, sin embargo, en la transferencia
--------------------------------------- de datos con AutoCAD son valores de 16 bits
--------------------------------------- con signo, comprendidos por lo tanto entre
--------------------------------------- -32768 y 32767.
Reales -------------------------------- Valores numricos con coma flotante de do--------------------------------------- precisin. Esto representa un mnimo de 14
--------------------------------------- dgitos representativos. Se pueden expresar
--------------------------------------- en notacin cientfica exponencial
mediante e o E.
Cadenas ----------------------------------- Valores textuales que contienen cadenas
de
--------------------------------------- caracteres en cdigo ASCII. Deben ir entre
--------------------------------------- comillas y se permite una longitud mxima
--------------------------------------- de 132 caracteres. Se pueden construir cadenas
--------------------------------------- mayores como veremos.
Descriptores de archivo --------------- Valores que representan un archivo abierto
--------------------------------------- para lectura o escritura.
Nombres de objetos de dibujo ---------- Valores que representan el "nombre"
hexade--------------------------------------- cimal de un objeto de la Base de Datos.
Conjuntos designados de AutoCAD ----- Valores que representan un conjunto de
se--------------------------------------- leccin de objetos de dibujo.
Funciones de usuario --------------------- Smbolo que representa el nombre de una
--------------------------------------- funcin definida por el usuario.
Funcin inherente o subrutina ----------- Smbolo con el nombre de una funcin
prede--------------------------------------- finida de AutoLISP. Se suelen denominar con
--------------------------------------- la abreviatura inglesa subrs. Pueden ser in--------------------------------------- ternas o externas.

ONCE.2.2. Procedimientos de evaluacin

La base de todo intrprete de LISP es su algoritmo evaluador. ste analiza cada
lnea de programa y devuelve un valor como resultado. La evaluacin slo se
realizar cuando se haya escrito una lista completa y sta podr ser cargada desde
un archivo de texto o tecleada directamente en la lnea de comandos de AutoCAD
14.
El primer elemento de la lista es comparado con todos los nombres de funciones
inherentes base o subrs internas de AutoLISP, con todos los nombres
de subrs externas cargadas desde aplicaciones ADS o ARX y en su caso con todos
los nombres de funciones de usuario cargadas en memoria. Si el nombre es
reconocido, se realiza la evaluacin de la expresin de AutoLISP. Esta puede
consistir en asignar un valor a una variable, cargar en memoria una funcin de
usuario, escribir un resultado en pantalla o en un archivo, dibujar un objeto grfico,
etc.
El primer elemento de la lista debe ser por tanto un nombre de funcin. El resto de
elementos se consideran argumentos de dicha funcin. La evaluacin en AutoLISP
se realiza de acuerdo a las siguientes reglas.
Primera:
Las listas se evalan quedando determinadas por el primer elemento. Si ste es un
nombre de funcin inherente o subrutina, los elementos restantes de la lista son
considerados como los argumentos de esa funcin. En caso contrario se considera
como un nombre de funcin definida por el usuario, tambin con el resto de
elementos como argumentos. Cuando los elementos de una lista son a su vez otras
listas, stas se van evaluando desde el nivel de anidacin inferior (las listas ms
"interiores"). El valor resultante en cada evaluacin de las listas "interiores", es
utilizado por las listas "exteriores". Por ejemplo:
(SETQ sx (SIN (* PI (/ x 180.0))))
La lista ms "interior" contiene como primer elemento el nombre de la funcin de
AutoLISP /que realiza el cociente o divisin del siguiente elemento entre los
restantes. La evaluacin de dicha lista devuelve el resultado del cociente, en este
caso el valor contenido en la variable xdividido entre el nmero real 180.0. Dicho
valor es utilizado como elemento en la lista circundante que empieza por la funcin
de AutoLISP * que realiza una multiplicacin o producto. Esta lista se evala
ofreciendo como resultado el producto de PI (3,14159) por el valor anterior. A su
vez el resultado interviene como argumento en la lista que empieza por la funcin
de AutoLISP SIN, que es evaluada obtenindose el seno. Este interviene por ltimo
como argumento de la lista ms exterior que empieza por la funcin de
AutoLISP SETQ , cuyo resultado es asignar o almacenar en la variable sx el valor del
seno. Este valor es devuelto por la lista de SETQ como resultado final.
Segunda:
Puesto que cada lista contiene un parntesis de apertura y otro de cierre, cuando
existen listas incluidas en otras, todos los parntesis que se vayan abriendo deben
tener sus correspondientes de cierre. Si se introduce desde el teclado una expresin
en AutoLISP a la que falta por cerrar algn parntesis, se visualiza un mensaje del

tipo n> donde n es un nmero que indica cuntos parntesis faltan por cerrar. Se
pueden introducir por teclado esos parntesis y subsanar el error. Por ejemplo:
Comando: (SETQ sx (SIN (* PI (/ x 180.0))
2> ))
0.523599

Tercera:
Tambin es posible evaluar directamente un smbolo (extraer por ejemplo el valor
actual contenido en una variable), introduciendo por teclado el signo de cerrar
admiracin seguido del nombre del smbolo. Esta evaluacin se puede producir
incluso en mitad de un comando. Por ejemplo, para suministrar como ngulo para
un arco el valor contenido en la variable x, se responde a la solicitud
de AutoCAD con !x. Por ejemplo:
Comando: !sx
0.523599

Cuarta:

Los valores enteros, reales, cadenas de texto y descriptores de archivos, devuelven

su propio valor como resultado. Los nombres de funciones inherentes o subrutinas
de AutoLISP devuelven un nmero interno hexadecimal (suele cambiar de una
sesin de dibujo a otra). Por ejemplo:
!72.5 devuelve 72.5
!"Inicio" devuelve "Inicio"
!SETQ devuelve <Subr: #1a93e24>

Quinta:
Los smbolos de variables participan con el valor que contienen (que les est
asociado) en el momento de la evaluacin. Por ejemplo:
!x devuelve 30
!sx devuelve 0.523599

Sexta:
Determinadas funciones de AutoLISP pueden devolver un valor nulo, que se
representa mediante la expresin nil. Por ejemplo:
Comando: (PROMPT "Bienvenido a AutoLISP\n")
Bienvenido a AutoLISP
nil
La funcin PROMPT escribe en la lnea de comando el mensaje especificado y
devuelve nil. El cdigo \n equivale a INTRO.

ONCE.2.3. Archivos fuente de programas

Las expresiones contenidas en un programa de AutoLISP pueden introducirse
directamente desde el teclado durante la edicin de un dibujo de AutoCAD,
escribirlas en un fichero de texto ASCII o ser suministradas por una variable del
tipo cadena, como ya se ha dicho varias veces.
Para una correcta evaluacin, las expresiones deben cumplir unos requisitos de
sintaxis, que se pueden resumir en los siguientes puntos:
Una expresin puede ser tan larga como se quiera. Puede ocupar varias lneas
del archivo de texto.
Los nombres de smbolos pueden utilizar todos los caracteres imprimibles (letras,
nmeros, signos de puntuacin, etc.) salvo los prohibidos que son: ( ) . ' " ;
Los nombres de smbolos no son sensibles a las maysculas.
As, seno y SENO representan el mismo nombre. Los nombres pueden contener
nmeros, pero no estar formados exclusivamente por nmeros. As, 1pt, pt1, p12 son vlidos como nombres de variables, pero no 21, que ser interpretado
como un valor numrico constante.
Los caracteres que terminan un nombre de smbolo o un valor explcito (una
constante numrica o de texto) son: parntesis de apertura y cierre, apstrofo,
comillas, punto y coma, espacio en blanco o final de lnea en el archivo. Estos
caracteres sirven de separacin entre elementos de una lista.
Los espacios en blanco de separacin entre smbolos son interpretados como un
solo espacio entre cada par de smbolos. Se recuerda que es necesario un espacio
en blanco para separar un smbolo del siguiente, siempre que no haya parntesis,
apstrofo, comillas o punto y coma. Debido a la longitud de las expresiones de
AutoLISP y a la profusin de parntesis que dificultan su lectura, suele ser norma
habitual realizar sangrados en las lneas del archivo de texto, para resaltar los
parntesis interiores de los exteriores. Todos los espacios aadidos son
interpretados como uno solo.
Los valores explcitos (constantes) de nmeros pueden empezar con el
carcter + o - que es interpretado como el signo del nmero.
Los valores de constantes de nmeros reales deben empezar con una cifra
significativa. El carcter punto (.) se interpreta como el punto decimal. Tambin se
admite + o - para el signo ye o E para notacin exponencial o cientfica. No es
vlida la coma decimal, ni tampoco abreviar como en .6 (hay que escribir 0.6).
Los valores de constantes con cadenas de texto son caracteres que empiezan y
terminan por comillas. Dentro de las cadenas se pueden incluir caracteres de
control mediante la contrabarra (\). Los cdigos permitidos son:
\\ ------ Carcter contrabarra (\).
\" ------ Carcter comillas (").
\e ------ Carcter de escape.

\n ------ Nueva lnea o retorno de carro.

\r ------ INTRO
\t ------ Carcter de tabulador TAB
\nnn ------ Carcter cuyo cdigo octal (no ASCII, que es decimal) es nnn.
\U+xxxx ------ Secuencia de caracteres de cdigo Unicode.
\M+nxxxx ------ Secuencia de caracteres multibyte.
Los cdigos deben ir en minsculas. Para incluir en una cadena un cdigo ASCII hay
que calcular su valor octal. Por ejemplo, el carcter dlar $ es ASCII 36; su valor
octal ser 44 y en la cadena habr que indicar el cdigo de control \44.
El apstrofo () se puede utilizar como abreviatura del comando QUOTE. El
comando QUOTEdevuelve el literal del smbolo. Es decir, cuando en una expresin un
smbolo aparece precedido por apstrofo o se le aplica la funcin de
AutoLISP QUOTE, no se evala con el valor que contiene en ese momento sino que
devuelve el propio nombre literal del smbolo.
Se pueden incluir comentarios en un archivo de texto con programas y
expresiones en AutoLISP, comenzando la lnea del archivo con un punto y coma (;).
A partir de donde se encuentre un punto y coma hasta el final de la lnea, AutoLISP
considera que son comentarios y no los tiene en cuenta. Tambin se pueden incluir
comentarios en mitad de una lnea u ocupando varias de ellas, si se sitan entre los
caracteres ;| y |;. Por ejemplo:
;Funcin de estado actual del dibujo.
(DEFUN funcion_1 (x / pt1 pt2)
(SETQ refnt0 ;| modos de referencia actualmente
activados |; (GETVAR "osmode"))
...
Los comentarios son tiles tanto para el autor del programa como para futuros
usuarios que accedan al archivo con el fin de modificarlo. Suele ser habitual situar
al principio del archivo el ttulo, autor y fecha de creacin. Posteriormente, una
explicacin general del programa, explicaciones particulares de cada funcin
intermedia, usos de variables, etc. Como muchas de las configuraciones de pantalla
de texto disponen de un ancho de 80 columnas, conviene que las lneas del archivo
de texto no sobrepasen los 80 caracteres.

ONCE.2.4. Variables predefinidas

Existen unos valores de smbolos de AutoLISP predefinidos. Son los siguientes:
PI. Es el valor del nmero real PI, es decir: 3,141592653589793.
PAUSE. Es una cadena de texto que consta de un nico carcter contrabarra. Se
utiliza para interrumpir un comando de AutoCAD despus de haberlo llamado
mediante la funcin de AutoLISP COMMAND. Esto permite al usuario introducir algn
dato.
T. Es el smbolo de True, es decir, cierto o verdadero (valor 1 lgico). Se utiliza
para establecer que determinadas condiciones se cumplen.

 Por ltimo el valor de nada, vaco o falso (0 lgico) se representa en AutoLISP

por nil. Este valor aparece siempre en minsculas y no es propiamente un
smbolo, ya que no est permitido acceder a l.

ONCE.3. PROGRAMANDO EN AutoLISP

A partir de ahora vamos a comenzar a ver poco a poco la manera de ir haciendo
nuestros programas en AutoLISP. Vamos a seguir un orden lgico de menor a
mayor dificultad, por lo que la estructura puede llegar a parecer un poco catica
para alguien que conozca el lenguaje. Tampoco es objetivo de este curso
profundizar en un mtodo complejo de programacin, sino proponer unas bases
para comenzar a programar que, con imaginacin y horas de trabajo, podr
convertirnos en programadores expertos de AutoLISP.
Todo lo visto hasta ahora resulta la parte rida de la programacin; parece que no
sirven de mucho esos conocimientos tericos mientras no pasemos a la prctica. De
aqu en adelante podremos ir entendiendo las 2 primeras secciones de
este MDULO y, si algo se qued en el tintero o algo hay que repetir de todo lo
expuesto hasta aqu, se completar y se explicar o repetir.
Comencemos, pues, con la programacin en AutoLISP para AutoCAD 14.

ONCE.3.1. Convenciones de sintaxis

Las convenciones utilizadas para las sintaxis en este MDULO van a ser las
siguientes:

Nombre del comando o funcin AutoLISP en maysculas.

Argumentos en minscula itlica, representados por un nombre mnemotcnico.
Argumentos opcionales encerrados entre corchetes itlicos (que no han de
escribirse).
Puntos suspensivos en itlica indican la posibilidad de indicar ms argumentos.

ONCE.4. OPERACIONES NUMRICAS Y

LGICAS
Explicaremos aqu la manera en que se realizan en AutoLISP las operaciones
matemticas, de comparacin y lgicas. El buen aprendizaje de ests tcnicas nos
ser tremendamente til a la hora de lanzarnos a la programacin pura.

ONCE.4.1. Aritmtica bsica

Para realizar las cuatro operaciones aritmticas bsicas existen cuatro funciones
AutoLISP que son +, -, * y /, estas se corresponden con la suma, resta,
multiplicacin y divisin.
La funcin de suma tiene la siguiente sintaxis:
(+ [valor1 valor2 valor3...])
Esto es, primero se indica el nombre de la funcin, como siempre en AutoLISP, que
en este caso es + y luego los argumentos de la misma, es decir, aqu los valores de
los distintos sumandos.
Esta funcin devuelve el resultado aditivo de todos los valores numricos
especificados como argumentos de la funcin. Por ejemplo:
(+ 14 10 20)
devolvera el valor 44. Para hacer la prueba nicamente debemos escribir dicho
rengln en la lnea de comandos de AutoCAD, pulsar INTRO y comprobar el
resultado.
NOTA: Al introducir el primer carcter de apertura de
parntesis, AutoCAD reconoce que se est escribiendo una expresin en AutoLISP,
por lo que nos permitir utilizar los espacios necesarios de la sintaxis sin que se
produzca un INTRO cada vez, como es habitual. Recordemos que todos los
elementos de una lista de AutoLISP han de ir separados por lo menos con un
espacio blanco. Probemos diferentes sintaxis utilizando ms espacios, o
tabuladores, y comprobemos que el resultado es el mismo; se interpretan los
espacios o tabuladores como un nico carcter de espacio en blanco.
NOTA: Hagamos la prueba de no introducir el parntesis final de la lista indicada.
Comprobaremos lo explicado en la segunda regla de la seccin ONCE.2.2.
Con la funcin + podemos indicar valores enteros o reales. Si todos los valores son
enteros el resultado ser entero, pero si uno o varios de ellos son reales o todos
ellos, el resultado ser real. Esto significa que nicamente es necesario introducir
un valor real para recibir una respuesta real. Por ejemplo, si introducimos la
siguiente lnea en la lnea de comandos enAutoCAD:
(+ 14 10 20.0)
el resultado ser:
44.0
o sea, un nmero real.
Esto aqu parece irrelevante, pero comprenderemos su utilidad al hablar, por
ejemplo, de la divisin.
Si indicamos un solo sumando con esta funcin, el resultado es el valor del propio
sumando. Por ejemplo:

(+ 23)
devuelve:
23

Y si se escribe la funcin sin argumentos, el resultado es 0 (funcin sin

argumentos: (+)).
Los valores indicados en la funcin de suma pueden ser directamente valores
numricos o nombres de variables numricas declaradas anteriormente, por
ejemplo:
(+ 10.0 x total)
En esta funcin, 10.0 es un valor constante real y x y total son dos nombres de
variables que han debido ser anteriormente declaradas; ya aprenderemos a
declarar variables. Si la variable no existiera se producira un error bad argument
type de AutoLISP.
Otros ejemplos con nmeros negativos:
(+ 10 23) devuelve 13
(+ -10 10) devuelve -20
NOTA: Si se produce algn error de sintaxis u otro, podemos acudir al final de
este MDULOpara ver una relacin de los mensajes de error de AutoLISP.
La funcin de resta, por su lado, tiene la siguiente sintaxis:
(- [valor1 valor2 valor3...])
Esta funcin devuelve la diferencia del primer valor con todos los dems indicados.
As por ejemplo:
(- 10 5)
da como resultado 5 y la siguiente expresin:
(- 10 5 2)

da como resultado 3. Esto es producto de restar 10 5 = 5 y, luego, 5 2 = 3; o

lo que es lo mismo 10 (5 + 2) = 3.
Al igual que en la suma, si se indican valores enteros el resultado ser entero, si se
indica uno real (con uno es suficiente) el resultado es real, si se indica un solo valor
se devuelve el mismo valor y si se escribe la funcin sin argumentos se devuelve 0.
As pues, si queremos un resultado real efectuado con nmeros enteros para
posteriores operaciones, deberemos indicar uno de los valores entero; de la
siguiente manera, por ejemplo:
(- 10 5.0 2)

o cualquier otra combinacin posible de uno o ms nmeros enteros.

Como se ha explicado para la suma, los valores de los argumentos para la resta
pueden ser constantes, eso s, siempre numricas, o variables:
(- tot num1 num2)
Llegados a este punto, podemos suponer ya las diferentes combinaciones que
podremos realizar con las distintas funciones aritmticas. Por ejemplo, es factible la
evaluacin de la siguiente expresin:
(+ 12 (- 2 -3))
cuyo resultado es 11. O sea, y como hemos explicado, se realizarn las operaciones
de dentro a fuera. En este ejemplo, se suma la cantidad de 12 a la diferencia 2
3, esto es, 12 + (2 3) = 11. Como vemos, existen dos listas, una interior
anidada a la otra que es, a la vez, argumento de la lista exterior. Ocurre lo mismo
con nombres de variables:
(- fer1 (+ -sum1 sum2) 23.44)
Con respecto al producto su sintaxis es la siguiente:
(* [valor1 valor2 valor3...])
Se evala el producto de todos los valores numricos indicados como argumentos.
Como anteriormente, si un valor es real el resultado es real. Un solo valor como
argumento devuelve el mismo valor. Ningn valor devuelve 0. Veamos un ejemplo:
(* 12 3 4 -1)
El resultado es -144. Veamos otros ejemplos:
(*
(*
((+

2 3)
val (- vax vad))
(* 12 2) 24)
(- -10 -5) (* 3 total 23))

NOTA: Si escribimos ms parntesis de los necesarios por la derecha se nos

mostrar un mensaje de error. Recordar que si no los escribimos nos da la opcin
de escribirlos despus, as como el nmero de ellos que faltan. De todas forma,
consltese el final del MDULO para la explicacin de los mensajes de error.
La sintaxis de la divisin es la que sigue:
(/ [valor1 valor2 valor3...])
La funcin / realiza el cociente del primer valor numrico por todos los dems, es
decir, divide el primer nmero por el producto de los dems. Por ejemplo:
(/ 10 2)
da como resultado 5. Y el ejemplo siguiente:

(/ 100 5 5)
da como resultado 4, es decir, 100 / 5 = 20 y, luego, 20 / 5 = 4; o lo que es lo
mismo, 100 / (5 * 5) = 4.
Otros dos ejemplos:
(/ 24 (* (+ 10.0 2) 12))
(/ 12 2 1)
Con respecto al cociente debemos realizar las mismas observaciones anteriores,
esto es, si se indica un solo valor se devuelve el mismo valor, si se indica la funcin
sin argumentos se devuelve 0 y si se indican valores enteros slo se devuelven
valores enteros. Esto ltimo cobra especial sentido en el caso de las divisiones, ya
que el cociente entre dos nmeros enteros puede ser un nmero real. Veamos el
siguiente ejemplo:
(/ 15 7)
Si introducimos esta lnea el resultado ser 2. El motivo es que, como hemos
especificado valores enteros, el resultado se muestra en forma de nmero entero,
con la parte decimal o mantisa truncada. Para asegurarnos de recibir una respuesta
correcta (con decimales significativos), deberemos introducir uno de los valores o
todos ellos, pero con uno es suficiente como valor real, de la siguiente forma:
(/ 15 7.0)
Ahora el resultado ser 2.14286. El nmero entero podra haber sido el otro:
(/ 15.0 7)
Esto debemos tenerlo muy en cuenta a la hora de realizar operaciones cuyo
resultado vaya a ser parte integrante de otra operacin o no que puede
devolver decimales. Vemos otros ejemplos de divisiones:

(/ -12.0 7.8 210)

(/ (+ (- 23.3 32) 12.03) (/ (* (+ 1.01 2.01) 100)))
(+ datos (/ grupo (* 100 2)))
NOTA: Evidentemente, la divisin por 0 produce un error de AutoLISP: divide by
zero.

1 fase intermedia de ejercicios

Realizar mediante AutoLISP las siguientes operaciones aritmticas (estn
expresadas en notacin informtica sencilla de una lnea):
(50 + 5) / 2
(200 * 5 3) / (4 / 2)
(10.23 (12.03 / 3)) * (12 + (2 * -2) ((12.5 / 2) * 2.65))

(19 + 23) / (10 + (23 / (23 / 19)))

((-20 / 5) 1) / (15.5 * ((15.5 1) / 12))

ONCE.4.2. Matemtica avanzada

Fuera aparte de las funciones aritmticas de nivel bsico, programando en AutoLISP
podemos realizar operaciones matemticas complejas como races cuadradas o
senos. Vamos a explicar aqu las funciones que controlan estas operaciones.

Las dos primeras que veremos son sencillas de entender y utilizar. Ambas se
refieren al incremento, positivo o negativo, de una unidad a un valor numrico.
(1+ valor)
Esta sintaxis corresponde a la funcin de incremento positivo de una unidad al valor
indicado. As, si queremos incrementar en 1 el valor 576, haremos:
(1+ 576)
Esto equivale a (+ 576 1) pero es de una forma ms cmoda; el resultado es 577.
NOTA: La funcin se denomina 1+ en s, por lo que no existe espacio entre 1 y +.
Podemos realizar estos incrementos con nombres de variable:
(1+ n)
lo que incrementar en una unidad el valor de n. Esto puede ser especialmente
necesario para controlar los llamados contadores-suma en programacin, del tipo:
(SETQ sum (1+ sum))
Esto ya lo veremos a la hora de declarar variables.
La siguiente funcin resta (incremento negativo) una unidad al valor numrico
indicado. Equivale a (- valor 1), pero de una forma ms cmoda.
(1- valor)
Por ejemplo:
(1- 32)
suyo resultado es 31.
Otros ejemplos de estas dos funciones:
(1- n)
(1- 67.90)
(1- -23)

(1+
(1+
(1(1-

-34.0)
(+ tuttot 1)
(* 2 2))
(* (/ 32 2) (+ 10 1.0)))

(ABS valor)
Esta funcin ABS devuelve el valor absoluto del nmero indicado o expresin
indicada. De esta forma, la siguiente expresin:
(ABS 23)
devuelve 23.
Las siguientes expresiones tienen el siguiente efecto indicado:
(ABS
(ABS
(ABS
(ABS
(ABS
(ABS

25.78) devuelve 25.78

45) devuelve 45
0) devuelve 0
13) devuelve 13
(/ 2 3.0)) devuelve 0.666667
(/ 2 -3.0)) devuelve 0.666667

(FIX valor)
FIX trunca un valor a su parte entera (positiva o negativa), es decir, de un nmero
real con decimales devuelve nicamente su parte entera. Pero, cuidado, no se
produce redondeo, slo un truncamiento.
Ejemplos:
(FIX
(FIX
(FIX
(FIX

32.79) devuelve 32
12.45) devuelve 12
(/ 10 3.0)) devuelve 3
(/ 10 3.0)) devuelve 3

(REM valor1 valor2 [valor3...])

Esta funcin AutoLISP devuelve el resto del cociente (mdulo) de los dos valores
introducidos en principio. Por ejemplo, la siguiente expresin devuelve 6 como
resultado:
(REM 20 7)
Dicho 6 es el resto que resulta de dividir 20 / 7. Si aplicamos la regla de la divisin
(dividendo es igual a divisor por cociente ms resto): 20 = 7 * 2 + 6, vemos que se
cumple correctamente.
Si se especifican ms de dos valores, el resto anterior es dividido entre el actual,
devolviendo el nuevo resto de la nueva divisin. Por ejemplo:
(REM 20 7 4)

da como resultado 2. El primer resto 6 se calcula de la forma explicada en el

ejemplo anterior y, el resultado final 2, se produce al dividir dicho primer resto
entre el tercer valor 4. Al dividir 6 / 4, nos da un resultado (que es igual a 1) y un
resto 2 (valor final obtenido). Y as sucesivamente.
Otros ejemplos:
(REM
(REM
(REM
(REM

1 2)
0 23)
(* 23 2) (- (+ 1 1) 45.5))
54 (* 3 -4))

Pasemos ahora a ver las funciones trigonomtricas, esto es, cmo calcularlas
mediante AutoLISP. La primera sintaxis se refiere al seno de un ngulo y es la
siguiente:
(SIN ngulo)
La funcin SIN devuelve el seno de un ngulo expresado en radianes. Ejemplos:
(SIN 1) devuelve 0.841471
(SIN (/ PI 2)) devuelve 1.0
NOTA: Como sabemos PI es un constante de AutoLISP, por lo que no hace falta
declararla como variable; ya tiene valor propio y es 3.14159. An as, se puede
calcular su valor exacto mediante la expresin: PI = 4 * arctag 1.
(COS ngulo)
COS devuelve el coseno de un ngulo expresado en radianes. Ejemplos:
(COS PI) devuelve 1.0
(COS (* 3 4)) devuelve 0.843854
NOTA: Ntese que PI es un valor real, por lo que el resultado ser real.
(ATAN valor1 [valor2])
Esta funcin ATAN devuelve el arco cuya tangente es valor1 expresada en radianes,
es decir, realiza el arco-tangente de dicho valor. Por ejemplo:
(ATAN 1.5) devuelve 0.98
Si se indica un segundo valor (valor2), ATAN devuelve el arco-tangente
de valor1 dividido porvalor2. Esto permite indicar la razn entre los lados de un
tringulo recto, es decir, escribir la tangente directamente como cociente del seno
entre el coseno. Si valor2 es 0, el valor devuelto ser igual a PI / 2 o a PI / 2
radianes, dependiendo del signo de valor1.
Ejemplos:
(ATAN 1 1)
(ATAN 1 (* 2 -4.5))

Estas son las tres funciones trigonomtricas de AutoLISP. En este punto se nos
plantean un par de problemas: cmo calculo las restantes funciones
trigonomtricas? y cmo convierto grados sexagesimales en radianes y viceversa?
La segunda cuestin es sencilla, ya que basta aplicar al frmula rad = grados * PI /
180 para convertir grados en radianes. La operacin inversa en fcilmente
deducible.
La primera pregunta tiene una respuesta no menos sencilla, y es que en la mayora
por no decir todos de los lenguajes de programacin nicamente nos
proporcionan estas funciones trigonomtricas bsicas y, a partir de ellas, podemos
calcular las funciones trigonomtricas derivadas inherentes. La manera se explica a
continuacin mediante notacin sencilla de una lnea:
Funcin derivada --------- Notacin
------------------------------------------------------------------------------------Secante (sec x) ------------ 1 / cos (x)
Cosecante (cosec x) ------- 1 / sen (x)
Arco-seno (arcsen x) ------- arctag (x / (1 x ^ 2))
Arco-coseno (arccos x) ----- 1.5707633 arctag (x / (1 x ^ 2))
Arco-secante (arcsec x) ---- arctag ( (x ^ 2 1)) + signo (x) 1) * 1.5707633
Arco-cosecante (arccos x) -- arctag (1/ (x ^ 2 1)) + signo (x) 1) * 1.570763
Arco-cotang. (arccotag x) --- 1.5707633 arctag (x)
NOTA: El smbolo ^ significa exponenciacin. es raz cuadrada. signo (x) se
refiere al signo del valor; si ste es positivo signo (x) valdr 1, si es negativo valdr
1 y si es cero valdr 0. No debemos preocuparnos ahora por esto, ya que
aprenderemos en breve o ms adelante con mayor soltura a realizar
exponenciaciones, races cuadradas y operaciones con signos.
Sigamos, pues, ahora con otras diferentes funciones que nos ofrece AutoLISP a la
hora de realizar operaciones matemticas. La siguiente dice referencia a las races
cuadradas; su sintaxis es:
(SQRT valor)
Esta funcin devuelve el resultado de la raz cuadrada del valor indicado, ya sea un
guarismo simple o una expresin matemtica, como siempre. As por ejemplo,
veamos unas expresiones con sus correspondientes evaluaciones:
(SQRT 4) devuelve 2.00
(SQRT 2) devuelve 1.4142
(SQRT (* 2 6)) devuelve 3.4641
La intencin de extraer una raz cuadrada de un nmero negativo produce el
error function undefined for argument de AutoLISP.
Por otro lado, la sintaxis para la funcin exponencial es la siguiente:
(EXPT base exponente)

EXPT devuelve el valor de base elevado a exponente. De esta forma, para elevar 5
al cubo (igual a 125), por ejemplo, escribiremos:
(EXPT 5 3)
Otro ejemplo:
(EXPT 2.3 7.23)
De esta forma, como sabemos, podemos resolver el resto de races (cbicas,
cuartas, quintas...) existentes. Ya que raz cbica de 32 es lo mismo que 32 elevado
a 1 / 3, podemos escribir la siguiente expresin:
(EXPT 32 (/ 1 3))
As tambin:
(EXPT 20 (/ 1 5))
(EXPT 10 (/ (+ 2 4) (- v23 rt sw2))
(EXPT 3 (/ 1 2))
NOTA: El intento de extraer races negativas de cualquier ndice producir el mismo
error explicado en SQRT.

(EXP exponente)
Esta funcin devuelve la constante (nmero) e elevada al exponente indicado. Se
corresponde con el antilogaritmo natural. Por ejemplo:
(EXP 1) devuelve 2.71828
(LOG valor)
LOG devuelve el logaritmo neperiano o natural (en base e) del valor indicado. Por
ejemplo:
(LOG 4.5) devuelve 125.0000
(GCD valor_entero1 valor_entero2)
Esta sintaxis se corresponde con la funcin de AutoLISP GCD, que devuelve el
mximo comn denominador de los dos valores indicados. Estos valores han de ser
obligatoriamente enteros, de no ser as, AutoLISP devuelve bad argument
type como mensaje de error. Veamos unos ejemplos:
(GCD 45 80) devuelve 5
(GCD 80 70) devuelve 10
(GCD (* 10 10) (/ 70 2)) devuelve 5
Si se indica un entero negativo el mensaje de error de AutoLISP es improper
argument.

Las dos ltimas funciones matemticas que veremos pueden sernos de gran ayuda
a la hora de programar. Una de ellas (MAX) devuelve el mayor de todos los nmeros
indicados en la lista. Su sintaxis es:

(MAX valor1 valor2...)

Los valores pueden ser nmeros enteros o reales, y tambin expresiones
matemtico-aritmticas. As por ejemplo:
(MAX 78.34 12 789 7)
devolver 789.0, ya que es el nmero mayor. Lo devuelve como real por la
aparicin de decimales en el elemento 78.34. Como sabemos, con la sola aparicin
de un valor real en una lista, el resultado es real.
Si el elemento mayor de la lista es un expresin matemtica, se devolver su
resultado, no la expresin en s, por ejemplo:
(MAX (* 10 10) 5)
devolver 100 como resultado (10 * 10).
Otro ejemplo:
(MAX 5 7 9)
devolver 5.
(MIN valor1 valor2...)
La funcin MIN, por su lado, devuelve el menor de todos los valores indicados en
lista. Las dems consideraciones son anlogas a la funcin anterior. Ejemplos:
(MIN 1 2 3 4 7) devuelve 1
(MIN 23.3 7 0) devuelve 0.0
(MIN (/ 7 3) 0.56) devuelve 0.56

Ejemplos de MAX y MIN con variables:

(MIN x y z)
(MIN (+ x1 x2) (+ y1 y2) (+ w1 w2) (+ z1 z2))
Y hasta aqu todas las funciones que tienen que ver con operaciones matemticas.
Pasaremos, tras unos ejercicios propuestos, a ver las operaciones de comparacin,
muy interesantes y sencillas de comprender.

2 fase intermedia de ejercicios

 Realizar mediante AutoLISP las siguientes operaciones matemticas (estn

expresadas en notacin sencilla de una lnea):
((20 3) * (8 2))
1 + 78.8 + ((78.8 ^ 2) / 2) + ((78.8 ^ 3) / 3)
(sen ( (80 * 28.002) cos (PI / 2))) / (PI (1 / 2))
arccos (100 / 2)
(124.6589 * (e ^ 2.3)) / (7 * 2)
ln (45 * (7 / 2))
(23.009 / 78.743) ^ (56.00123 1)
Realcense ejercicios de clculo de valores mayores y menores de listas, as como
de mximos comunes denominadores.
Realizar un par de ejercicios de incremento y decremento de una unidad a
valores.
NOTA: Las operaciones en general siguen en AutoLISP la jerarqua de las
operaciones matemticas: parntesis internos, parntesis externos, operadores
unitarios (signos), potenciacin, multiplicacin y divisin, suma y resta, operadores
relacionales (mayor que, menor que...) y operadores lgicos (lgebra de Boole). Y
cuando existen varios operadores en el mismo nivel, se ejecutan de izquierda a
derecha. Ahora mismo veremos operadores relacionales o de comparacin y, luego,
el lgebra de Boole en AutoLISP.

ONCE.4.3. Operaciones relacionales

Las funciones que veremos a continuacin se denominan relacionales o de
comparacin, y es que comparan valores, ya sean numricos o textuales (cadenas)
emitiendo un resultado verdadero o falso, segn la comparacin. Estas funciones
son conocidas por todos (igual, mayor que, menor o igual que...), slo queda
determinar cmo se utilizan y cul es su sintaxis en AutoLISP.
Como hemos dicho el resultado de la evaluacin solo puede ser uno de
dos: T (True) que representa el verdadero o cierto, o nil que representa el falso o
nulo.
NOTA: Con la devolucin nil por parte de AutoLISP nos empezamos a familiarizar
ahora y la veremos muchas veces.
Comencemos por el igual o igual que, cuya sintaxis es la siguiente:
(= valor1 [valor2...])
La funcin = compara todos los valores especificados uno como mnimo,
devolviendo T si son todos iguales o nil si encuentra alguno diferente. Los valores
pueden ser nmeros, cadenas o variables (numricas o alfanumricas). As por
ejemplo:
(= 5 5) devuelve T
(= 65 65.0) devuelve T
(= 7 54) devuelve nil

(= 87.6 87.6 87.6) devuelve T

(= 34 34 34 34) devuelve nil

Veamos ahora algn ejemplo con cadenas:

"hola" "hola") devuelve T
"casa" "cAsa") devuelve nil
"H" "H" "H" "H") devuelve T
"hola ahora" "hola ahora") devuelve nil

(=
(=
(=
(=

NOTA: Ntese, como adelanto, que las cadenas literales han de ir encerradas entre
comillas, como en casi todos los lenguajes de programacin.

Con variables declaradas, que ya veremos, sera de la misma forma. Si slo se

indica un valor en la lista, AutoLISP devuelve T.
NOTA: Hay que tener en cuenta que esta funcin slo compara valores y no listas o
expresiones. Si, por ejemplo, se tienen dos variables pt1 y pt2 con dos puntos que
son listas de tres elementos (una coordenada X, una coordenada Y y una
coordenada Z), para comparar la igualdad de ambos habra que recurrir a una
funcin lgica como EQUAL, que veremos un poco ms adelante.
(/= valor1 [valor2...])

Esta funcin /= (distinto o desigual que) devuelve T si alguno o algunos de los

valores comparados de la lista son diferentes o distintos de los dems, por ejemplo
en los siguientes casos:
(/= 2 3)
(/= "texto" "textos")
(/= (* 2 2) (* 2 4) (* 2 3)
Devuelve nil si todos los valores son iguales, por ejemplo:
(/=
(/=
(/=
(/=

"casa" "casa" "casa")

"1 2 3" "1 2 3" "1 2 3" "1 2 3" "1 2 3")
32 32 32 32)
(* 10 10) (* 25 4))

Si nicamente se indica un valor, AutoLISP devuelve T.

(< valor1 [valor2...])
Esta sintaxis se corresponde con la comparacin menor que. Es una funcin
AutoLISP que devuelve T si efectivamente el primer valor comparado es menor que
el segundo. Si existen diversos valores, cada uno ha de ser menor que el siguiente
para que AutoLISP devuelva T. Si no se devuelve nil. Veamos algunos ejemplos:

(<
(<
(<
(<

2 3) devuelve T
3 4 5 89 100) devuelve T
3 4 5 6) devuelve nil
(* 2 2) (/ 5 3)) devuelve nil

En el caso de cadenas o variables alfanumricas (las que contienen cadenas), la

comparacin se efecta segn el valor de los cdigos ASCII. Por lo tanto, ser el
orden alfabtico ascendente (de la A a la Z) la manera de considerar de menor a
mayor los caracteres, teniendo en cuenta que el espacio blanco es el carcter de
menor valor y que las letras maysculas son de menor valor que las minsculas.
Ejemplos:
(<
(<
(<
(<

"a"
"z"
"A"
"f"

"b") devuelve T
"h") devuelve nil
"a" "b") devuelve T
"S") devuelve nil

Si las cadenas tienen ms caracteres se comparan de la misma forma:

(< "abc" "abd") devuelve T
(< "abc" "ab") devuelve nil
No es posible comparar cadenas literales con nmeros; AutoLISP devuelve un
mensaje de error que dice bad argument type. Con variables que contienen
valores numricos o literales se realizara de la misma manera:
(< valor1 valor2 total)
(< -12 7 km hrs)
(< autor1 autor2 autor3 auto4 autor5)

(<= valor1 [valor2...])

Esta es la funcin menor o igual que. Funciona de la misma forma que la anterior
pero teniendo en cuenta que devolver T si cada valor es menor o igual que el
anterior. Si no devolver nil. He aqu unos ejemplos:
(<= 10 30 30 40 50 50) devuelve T
(<= 12.23 12.23 14) devuelve T
(<= 56 57 57 55) devuelve nil
Las dems consideraciones son idnticas a las de la funcin precedente.
(> valor1 [valor2...])
Al igual que en la comparacin de menor que, pero de manera inversa, esta funcin
devuelve Tsi cada valor especificado, sea numrico sea cadena, es mayor que el
siguiente, esto es, si se encuentran ordenados de mayor a menor. Si no
devuelve nil. Por ejemplo:
(> 10 5 4.5 2) devuelve T
(> "z" "gh" "ab") devuelve T
(> 23 45) devuelve nil

Otros ejemplos:
(> saldo divid)
(> pplanta ppiso pcubierta)

(>= valor1 [valor2...])

Similar a los anteriores, establece la comparacin mayor o igual que. Se
devolver T si y slo si cada valor es mayor o igual que el que le sucede, si no, nil.
Las dems consideraciones son idnticas a las otras funciones similares explicadas.
Ejemplos:
(>= 33 23 23 12 12 54) devuelve nil
(>= 24 24 24 23 23 0.01 3) devuelve T

3 fase intermedia de ejercicios

Indicar el resultado de AutoLISP (T o nil) ante las siguientes proposiciones:
(= 23 23.0)
(= 48.0 (* 6 8))
(= "AutoLISP" "autolisp" "aUtOlIsP")
(/= (/ 7 2) (/ 2 7))
(/= "libro" "libro ")
(< 3 5 6 (+ 5 67))
(<= "A" "A" "bc" "zk" "zk")
(> "coche" "mesa")
(>= "coche" "cochecito")
(>= "cochu" "coche" "coche" "cocha")
(>= "" "" "a")

ONCE.4.4. Operaciones lgicas

Adems de lo estudiado hasta ahora, existen cuatro operaciones lgicas referidas al
lgebra de Boole. Estas operaciones son el Y lgico, el O lgico, la identidad y
el NO lgico. Adems, existe una quinta funcin que veremos al final denominada
de identidad de expresiones y que es un poco especial.
Las cuatro funciones que vamos a ver actan como operadores lgicos y devuelven,
al igual que las anteriores, nicamente los resultados T (cierto) o nil (falso).
(AND expresin1 [expresin2...])

Esta funcin realiza el Y lgico de una serie de expresiones indicadas que

representan otras tantas condiciones. Esto significa que evala todas las
expresiones y devuelve T si ninguna de ellas es nil. En el momento en que alguna
es nil, abandona la evaluacin de las dems y devuelve nil. Es decir, se deben
cumplir todas y cada una de las condiciones. Veamos un ejemplo:

(AND (<= 10 10) (>= 10 10)) devuelve T

Esto significa que, si se cumple la condicin de la primera lista (<= 10 10) y,
adems, se cumple la de la segunda lista (>= 10 10) devolver T. Como esto es
as, devuelve T.
De otra forma, si una de las condiciones no se cumple, devuelve nil, por ejemplo
en el siguiente caso:
(AND (= 10 10) (> 10 10))
La primera condicin en verdadera (10 es igual a 10), pero la segunda es falsa (10
no es mayor que 10). Como una ya no se cumple se devuelve nil. Han de
cumplirse todas las condiciones para que sea el resultado verdadero. Veamos otros
dos ejemplos:
(AND (= 10 10) (> 23 22.9) (/= "camin" "camioneta")) devuelve T
(AND (<= "A" "a") (= 5 7)) devuelve nil
No tiene mucho sentido indicar una sola expresin con esta funcin. Las dos
siguientes son idnticas y producen el mismo resultado:
(AND (= 20 -20))
(= 20 -20)
Ambas devuelven nil.
(OR expresin1 [expresin2...])

Realiza un O lgico de una serie de expresiones que representan otras tantas

condiciones. Evala las expresiones y devuelve nil si todas ellas son nil. En el
momento en que encuentre una respuesta distinta de nil, abandona la evaluacin
y devuelve T. sta es precisamente la mecnica del O lgico, es decir, basta que se
cumpla una de las condiciones para que la respuesta sea verdadera o cierta.
El siguiente ejemplo compara nmeros y devuelve nil:
(OR (< 20 2) (> 20 2))
O sea, si es menor 20 que 2 que no lo es o si es mayor 20 que dos que s lo
es, devuelve T. El cumplirse una de las dos condiciones es condicin suficiente
para que devuelva T. Veamos otro ejemplo:
(OR (= 20 2) (> 2 20)) devuelve nil
En este caso ninguna de las dos condiciones se cumplen (ambas son nil), as que
el resultado final ser nil.
Como en el caso de la funcin AND, no tiene sentido utilizar una sola expresin, ya
que el resultado sera el mismo que al escribirla sola. Veamos otros ejemplos:

(OR (>= 30 30 20 5) (<= -5 5 4 0)) devuelve T

(OR (< (* 2 8) (* 2 3)) (= (/ 8 2) (* 4 1))) devuelve T
(OR (= "carro" "carreta") (= "casa" "caseta") (= 2 3) devuelve nil
Recapitulando, y para afianzar estos dos ltimos conocimientos, decir
que AND obliga a que se cumplan todas las condiciones para devolver T. Sin
embargo, a OR le basta con que una de ellas se cumpla para devolver T. Digamos,
en lenguaje coloquial, que AND es "si se cumple esto, yesto, y esto, y... es vlido",
y OR es "si se cumple esto, o esto, o esto, o... es vlido".
Veamos ahora otra funcin lgica para comparar expresiones. Se llama EQUAL y su
sintaxis es la siguiente:
(EQUAL expresin1 expresin2 [aproximacin])
Esta funcin compara las dos expresiones indicadas, si son idnticas devuelve T, si
difieren en algo devuelve nil.
A primera vista puede parecer igual a la funcin = (igual que) estudiada, sin
embargo, sta nicamente comparaba valores; EQUAL tiene la capacidad de poder
comparar cualquier expresin o lista de expresiones. De esta forma, podemos
utilizar EQUAL de la misma forma que =, as:
(EQUAL 2 2) devuelve T
(EQUAL 3 5) devuelve nil
Pero no tiene mucho sentido, ya que tenemos la funcin =.
Reservaremos EQUAL para lo expuesto, es decir, para la comparacin de listas de
expresiones.
As pues, y adelantndonos a algo que veremos un poco ms tarde, diremos que la
expresin de las coordenadas de un punto 3D se escribira de la siguiente forma:
(20 20 10)
El apstrofo es la abreviatura de la funcin QUOTE de AutoLISP, que toma como
literales, y sin evaluar, las expresiones que le siguen. De esta forma, para comparar
la identidad de dos puntos haramos, por ejemplo:
(EQUAL (20 20 10) (20 20 10)) devuelve T
(EQUAL (20 5 10) (20 20 10)) devuelve nil
NOTA: La funcin QUOTE se ve ampliada en la seccin ONCE.5.1.
El argumento optativo aproximacin se utiliza cuando se comparan expresiones
cuyos resultados son nmeros reales y puede haber una pequea diferencia
decimal que no queramos considerar desigual. Con este argumento suministramos
a la funcin un valor de aproximacin decimal respecto al cual se creern iguales
los resultados. Por ejemplo:
(EQUAL 23.5147 23.5148) devuelve nil
(EQUAL 23.5147 23.5148 0.0001) devuelve T

(NOT expresin)
La funcin NOT devuelve el NO lgico, es decir, si algo es verdadero devuelve falso y
viceversa. As, cuando el resultado sea distinto de nil (T), devolver nil; cuando
el resultado sea nil, devolver T. Por ejemplo:
(NOT (= 2 2)) devuelve nil
(NOT (/= 2 2)) devuelve T
(EQ expresin1 expresin2)
Esta funcin no es propiamente lgica, sino que se denomina de identidad de
expresiones. An as, la introducimos en este apartado por su similitud con las
anteriores.
EQ compara las dos expresiones (slo dos y ambas obligatorias) indicadas y
devuelve T si ambas son idnticas o nil en caso contrario. Se utiliza sobre todo
para comparar listas y ver si hay igualdad estructural.
La diferencia de EQ con EQUAL es que sta ltima compara los resultados de evaluar
las expresiones, mientras que EQ compara la identidad estructural de las
expresiones sin evaluar. Por ejemplo, y adelantando la funcin SETQ que enseguida
veremos, podemos hacer lo siguiente:
(SETQ list1 (x y z))
(SETQ list2 (x y z))
(SETQ list3 list2)
(EQ list1 list2) devuelve T
(EQ list2 list3) devuelve nil
Se observa que list1 y list2 son exactamente la misma lista por definicin, estn
declaradas con SETQ y por separado, siendo sus elementos iguales. Pero list3 es,
por definicin, igual alist2 y no a list3, aunque sus elementos sean iguales. Es
por ello que, en la segunda evaluacin, EQ devuelve nil.
NOTA: Comprenderemos enseguida el funcionamiento y base de la funcin SETQ, no
hay preocuparse.

4 fase intermedia de ejercicios

Indicar el resultado de AutoLISP (T o nil) ante las siguientes proposiciones:
(AND (= (* 20 20) (/ 800 2)) (> 300 200 500))
(AND (>= "a" "a") (>="z" "a") (>= " " " ") (>= "" ""))
(AND (OR (= 2 2) (> 3 6)) (OR (= 7 5) (= 0 0)))
(EQUAL (AND (= 1 10) (= 1 1)) (OR (>= 3 2 1 0) (<= 0 2)))
(OR (AND (= 1 1) (= 2.0 2)) (OR (NOT (= 1 1)) (= 2.0 2)))
NOTA: Aprciese la capacidad de poder anidar y combinar expresiones.
Y hasta aqu llega esta parte de funciones matemticas, lgicas y de comparacin.
Probablemente el lector estar pensando que de poco sirve lo expuesto hasta

ahora: qu ms dar que una expresin matemtica me d un resultado si luego no

puedo operar con l; que importar que una proposicin lgica me
devuelva T o nil si no me sirve para otra cosa.
Paciencia... En el mundo de la programacin hay que empezar desde abajo y,
aseguramos que un buen dominio abstracto de lo visto hasta ahora proporcionar
un gran nivel de soltura a la hora de programar de verdad. Seguramente, adems,
aquella persona que sepa programar en algn lenguaje existente, habr
comprendido algo ms ya que todos son muy parecidos. El nefito comenzar a
ver las cosas claras inmediatamente.
A partir de la siguiente seccin comenzaremos a ver para qu sirve todo esto y
cmo utilizarlo prcticamente en programas propios.
Autor: Jonathan Prstamo Rodrguez.
Para: La Web del Programador.

http://www.lawebdelprogramador.com/cursos/autocad/once_1.php

Velocidad de ejecucin para lenguajes de

personalizacin de AutoCAD
Actualmente AutoCAD permite su personalizacin mediante
cuatro lenguajes de programacin que pueden ser usados
para realizar desde tareas simples, repetitivas y con mucha
frecuencia
tediosas,
hasta
complejas
aplicaciones
especializadas en cualquier campo del diseo grfico asistido
por computadora.
Estos cuatro lenguajes incluyen AutoLISP, Visual LISP, Visual
Basic (VBA) y C++ (ObjectARX/ObjectDBX). Visual Lisp es el
hermano mayor de AutoLisp y aunque podemos decir que
engloba a AutoLISP prefiero tratarlos como lenguajes
separados y entender Visual LISP como el lenguaje AutoLISP
con extensiones ActiveX (u OLE, que es lo mismo).
Ninguno de estos cuatro lenguajes es mejor ni peor que otro,
sencillamente son adecuados o no para la realizacin de una
tarea concreta. No obstante, personalmente la velocidad de
ejecucin de los algoritmos que implemento es una cuestin
que me preocupa mucho. Y aunque influye mucho ms sobre
el rendimiento la forma de implementar, el propio diseo del
lenguaje tambin tiene un peso especfico considerable.
Con el fin de comparar la velocidad de ejecucin de estos
cuatro lenguajes he preparado una sencilla prueba que

permita realizar esta comparacin. Aunque ya supongo

cualitativamente los resultados de la prueba, tengo curiosidad
por cuantificarlos. Por ello he preparado la siguiente prueba.
Ejecutar una rutina que dibuje un nmero determinado de
crculos concntricos y al finalizar muestre su tiempo de
ejecucin. Este sera ms o menos supseudocdigo :
funcion DibujaCirculo(centro, radio)
{
AadeEntidadCirculoalModeloEspacio(centro, radio)
}
funcion concir()
{
solicitarepeticiones(n)
tomatiempoinicial()
repite n
{
DibujaCirculo(centro, radio)
radio = radio + 0.001
}
tomatiempofinal()
}

presentatiempoejecucion()

He intentado implementar las rutinas en los cuatro lenguajes

en la forma en que se parezcan lo mximo posible sin alterar
la metodologa de programacin inherente a cada uno de los
lenguajes de programacin bajo AutoCAD. Quizs se podran
optimizar
algunas
rutinas metiendo algunosparches para
evitar ciertas llamadas, etc. pero entonces creo que la prueba
no tendra sentido. Por ello he intentado respetar lo mximo
posible lasbuenas formas de programacin para todas las
rutinas y sus respectivos lenguajes en los que han sido
implementadas.
La prueba consta de cinco programas que corresponden con
lo siguiente :
LSP : programa en AutoLISP. Comando : concirlsp
FAS : programa en AutoLISP compilado con Visual LISP.
Comando : concirfas

 VLX : programa en AutoLISP con las extensiones ActiveX

de Visual LISP. Comando : concirvlx
VBA : programa en Visual Basic (VBA).
Macro : concirVBA
ARX : programa en C++ (ObjectARX).
Comando : concirarx
Los fuentes y los programas compilados se adjuntan en un
archivo. Aqu coloco las partes principales de cada uno de
ellos :
AutoLISP (LSP) y Visual LISP (FAS)
(defun DibujaCirculo (centro radio)
;crear la nueva entidad circle
(entmake (list '(0 . "CIRCLE") (cons 10 centro) (cons 40
radio)))
)
(defun c:concirlsp ( / centro radio n t0 tf tiempo)
;mensaje de consola
(princ "\nPrueba de velocidad [LSP].\n")
;inicializar las variables
(setq centro (list 0 0 0))
(setq radio 1.000)
;solicitar el nmero de repeticiones
(setq n (getint "\nNmero de repeticiones : "))
(if (or (= n nil) (<= n 0)) (setq n 1000))
(princ "\nRealizando la prueba para ")
(princ n)
(princ " repeticiones ...\n")
;tomar el tiempo inicial
(setq t0 (getvar "DATE"))
;repetir n veces ...
(repeat n
(DibujaCirculo centro radio)
(setq radio (+ radio 0.001))
)
;tomar el tiempo final
(setq tf (getvar "DATE"))
;mostrar los milisegundos

(setq tiempo (* (- tf t0) 86400000))

(princ
(princ
(princ
(princ
(princ

"\nTiempo de ejecucin de la prueba = ")

(fix tiempo))
" ms, con ")
n)
" repeticiones.")

(princ)
)

Visual LISP (VLX)

(defun DibujaCirculoVLX (centro radio)

;aadir la nueva entidad circle a la base de datos de AutoCAD

(vla-addCircle *MODELSPACE* (vlax-3D-point centro) radio)

(defun c:concirvlx ( / centro radio n t0 tf tiempo)

;capturar los errores
(defun *error* (msg)
(setq *error* nil)
;liberar
(setq *MODELSPACE* nil)
(princ msg)
)
;mensaje de consola
(princ "\nPrueba de velocidad [VLX].\n")
;cargar las funciones extendidas de AutoLISP
(vl-load-com)
;obtener un puntero al modelo espacio del documento activo
(setq *MODELSPACE* (vla-get-ModelSpace (vla-get-ActiveDocument
(vlax-get-Acad-Object))))
;inicializar las variables
(setq centro (list 0 0 0))
(setq radio 1.000)
;tomar el nmero de repeticiones
(setq n (getint "\nNmero de repeticiones : "))
(if (or (= n nil) (<= n 0)) (setq n 1000))
(princ "\nRealizando la prueba para ")
(princ n)
(princ " repeticiones ...\n")
;tomar el tiempo inicial
(setq t0 (getvar "DATE"))
;repetir n veces ...
(repeat n

(DibujaCirculoVLX centro radio)

(setq radio (+ radio 0.001))
)
;tomar el tiempo final
(setq tf (getvar "DATE"))
;mostrar los milisegundos
(setq tiempo (* (- tf t0) 86400000))
(princ
(princ
(princ
(princ
(princ

"\nTiempo de ejecucin de la prueba = ")

(fix tiempo))
" ms, con ")
n)
" repeticiones.")

;liberar
(setq *MODELSPACE* nil)
(princ)
)

Visual Basic (VBA)

Option Explicit
'
Public Sub DibujaCirculo(ByRef centro As AcPoint, _
ByRef radio As Double)
'
On Error Resume Next
'
Dim centerPoint(0 To 2) As Double
'
'/* preparar la matriz */
With centro
'
centerPoint(0) = .X
centerPoint(1) = .Y
centerPoint(2) = .Z
'
End With
'
'/* usaremos vinculacin temprana para optimizar
'
la velocidad de ejecucin */
Dim objCircle As AcadCircle
'
Set objCircle = ThisDrawing.ModelSpace.AddCircle(centerPoint,
radio)
'
End Sub
'
Public Sub concirVBA()
'
On Error Resume Next
'
Dim centro
As New AcPoint
Dim radio
As Double
Dim n
As Integer
Dim t0
As Double
Dim tf
As Double

Dim i
As Integer
Dim tiempo
As Double
Dim promptStr
As String
'
'/* mensaje de consola */
ActiveDocument.Utility.Prompt (vbCrLf & "Prueba de velocidad
[VBA].")
'
'/* inicializar las variables */
'
With centro
'
.X = 0#
.Y = 0#
.Z = 0#
'
End With
'
radio = 1#
'
'/* solicitar el nmero de repeticiones */
'
Err.Clear
'
n = ActiveDocument.Utility.GetInteger(vbCrLf & "Nmero de
repeticiones : ")
'
'/* chequear si se cancel */
If (Err.Number = -2147352567) Then
'
ActiveDocument.Utility.Prompt ("*Cancel*" & vbCrLf)
'
Exit Sub
'
End If
'
If (n <= 0) Then
'
n = 1000
'
End If
'
ActiveDocument.Utility.Prompt (vbCrLf & "Realizando la prueba para
" & _
n & " repeticiones ..." & vbCrLf)
'
'/* tomar el tiempo inicial */
t0 = ActiveDocument.GetVariable("DATE")
'
'/* repetir n veces ... */
For i = 1 To n
'
Call DibujaCirculo(centro, radio)
'
radio = radio + 0.001
'
Next i
'
'/* tomar el tiempo final */
tf = ActiveDocument.GetVariable("DATE")
'

'/* calcular los milisegundos */

tiempo = (tf - t0) * 86400000#
'
promptStr = vbCrLf & "Tiempo de ejecucin de la prueba = " & _
CLng(tiempo) & " ms, con " & n & " repeticiones." &
vbCrLf
'
ActiveDocument.Utility.Prompt promptStr
'
'/* liberar */
'
Set centro = Nothing
'
End Sub

C++ (ObjectARX)
Acad::ErrorStatus appendEntityToModelSpaceBlockTableRecord(AcDbEntity
*pEntity, AcDbObjectId& ID)
{
Acad::ErrorStatus
es;
AcDbBlockTable *pBlockTable;
// obtener un puntero a la BlockTableRecord Modelo Espacio
es = acdbHostApplicationServices()->workingDatabase()
->getSymbolTable(pBlockTable, AcDb::kForRead);
if (es != Acad::eOk)
return es;
AcDbBlockTableRecord *pBlockTableRecord;
es = pBlockTable->getAt(ACDB_MODEL_SPACE, pBlockTableRecord,
AcDb::kForWrite);
pBlockTable->close();
if (es != Acad::eOk)
return es;
// aadir la entidad a la BlockTableRecord
es = pBlockTableRecord->appendAcDbEntity(ID, pEntity);
// se cierra la entidad
pEntity->close();
pBlockTableRecord->close();
}

return es;

void DibujaCirculo(AcGePoint3d &centro, double &radio)

{
AcDbCircle
*pCircle;
AcGeVector3d
normal(0.0, 0.0, 1.0);
// crear la nueva entidad circle ...
try
{
pCircle = new AcDbCircle(centro, normal, radio);

}
catch(const std::bad_alloc&)
{
acdbFail("\nError de asignacin de memoria
[DibujaCirculo].");
return;
}
AcDbObjectId ID;
// ... y aadirla a la base de datos de AutoCAD
if
(appendEntityToModelSpaceBlockTableRecord((AcDbEntity*)pCircle, ID) !=
Acad::eOk)
{
if (pCircle)
{
delete pCircle;
}
acdbFail("\nError al aadir la entidad a la Base de
Datos [DibujaCirculo].");
}

return;

return;
}
// This is command 'CONCIRARX'
void TPLDPruebasconcirarx()
{
// mensaje de consola
acutPrintf("\nPrueba de velocidad [ARX].\n");
// inicializar las variables
AcGePoint3d
centro(0, 0, 0);
double
radio = 1.000;
// solicitar el nmero de repeticiones
int n;
if (acedGetInt("\nNmero de repeticiones : ", &n) == RTCAN)
{
acutPrintf("*Cancel*\n");
return;
}
if (n <= 0)
{
n = 1000;
}
acutPrintf("\nRealizando la prueba para %d repeticiones ...",
n);
// tomar el tiempo inicial

struct resbuf rb;

if (acedGetVar("DATE", &rb) != RTNORM)
{
acdbFail("\nError al tomar la variable de Sistema
DATE.");
}
double t0 = static_cast<double>(rb.resval.rreal);
// repetir n veces ...
for (int i = 0; i < n; i++)
{
DibujaCirculo(centro, radio);
}

radio += 0.001;

// tomar el tiempo final

if (acedGetVar("DATE", &rb) != RTNORM)
{
acdbFail("\nError al tomar la variable de Sistema
DATE.");
}
double tf = static_cast<double>(rb.resval.rreal);
// mostrar los milisegundos
double tiempo = (tf - t0) * 86400000;
acutPrintf("\nTiempo de ejecucin de la prueba = %.0f ms, con
%d repeticiones.", tiempo, n);
}

return;

Tabla de resultados
Pues aqu est el resultado de la prueba hecho con un P4 a
1.7GHz con 256MB de RAM y bajo AutoCAD 2000. Antes de
presentar la tabla he de decir que personalmente me
esperaba lo siguiente.
AutoLISP sera es ms lento de todos, seguido muy de cerca
por el formato FAS. Posteriormente crea que el formato VLX
ira muy a la par con VBA y no hubiera sabido decidirme entre
uno y otro para la tercera posicin. Y por ltimo me esperaba
una victoria aplastante de ObjectARX. Pero hay sorpresas :
REPETICIONES

Tiempo en milisegundos
LSP

FAS

VLX

VBA

ARX

50

10

10

19

10

500

210

169

221

120

40

1000

431

340

440

250

90

2500

1061

871

1080

631

220

5000

2113

1811

2172

1282

431

10000

4126

3925

4336

2564

871

Qu ha ocurrido con VLX?. Bien, pues buscando un poco por

la red encontr esto :
Will My Program Run Faster?
There are two sides to the time savings issue in relationship to a
programming tool such as Visual LISP.
A topic of interest to many programmers is speed of execution, or more
succinctly, "Will my program run
faster?" The answer is basically an affirmative-with some caveats.
There are subtle differences in the
way the individual interpreters evaluate program code, and, as a
consequence of the way they are built,
programs will run at different speeds. The style of the programming
will influence the speed more than
anything else. For example, when I tested the speed of Visual LISP
versus AutoLISP, I found a case where
AutoLISP was faster. AutoLISP handled a recursion problem faster than
Visual LISP. The example used was
the common factorial computation function. Even after the Visual LISP
program was compiled into an ARX
module, AutoLISP was slightly faster at solving the problem. However,
in the other tests using more
common iteration structures and involving floating point arithmetic,
the Visual LISP program was two
to three times faster on a regular basis. You can expect AutoLISP
applications that involve numerical
work to run faster in the Visual LISP environment (once properly
prepared).
Fuente:
Bill Kramer
http://cadence.advanstar.com/1998/0898/focus0898.html

Tengan cuidado con este tipo de cosas ya que a

veces creemos cosas errneamente que nos pueden llevar a
realizar malos diseos y no entender el porqu de ello. As
que cuando la velocidad de ejecucin sea un item a tener en
cuenta ojo con las funciones que empleemos, parece ser que
no por ser una funcin ms moderna est ms optimizada o
tenga que ser ms rpida, aunque la mayora estaremos de
acuerdo en que debera serlo.

Cualquier duda u opinin

a davidesqb@hotmail.com.

puede

hacrmela

Un saludo.
David Esquinas.
http://topoligonar.galeon.com/tutoriales/test1/test1.html

Biblioografia.-

llegar

https://sis2430.files.wordpress.com/2009/11/tema-6.pdf