doc/es/giac_es.texinfo

\input texinfo   @c -*-texinfo-*-
@c %**start of header
@setfilename giac_es.info
@settitle Giac API
@comment Carleos 20020729 for Debian packaging added:
@dircategory Math
@direntry
* Giac en castellano: (giac_es).         Programa de calculo simbolico por Bernard Parisse
@end direntry
@documentlanguage es
@documentencoding ISO-8859-1
@c %**end of header

@setchapternewpage odd

@titlepage
@sp 10
@comment The title is printed in a large font.
@center @titlefont{Giac/Xcas}

@c The following two commands start the copyright page.
@page
@vskip 0pt plus 1filll
Copyright @copyright{} 2001 B. Parisse, Institut Fourier
Spanish Translation by J.Manrique Lopez, ETSIG
Last revision 02/07/2002
@end titlepage

@node Top, Instalaci�n, , (dir)
@comment node-name, next,previous, up

Giac es una librer�a en C++ con tipos para manipulaciones algebraicas.
Xcas es una GUI (Interface Gr�fica) unida a Giac que permite las funcionalidades
de un Sistema de Algebra Computerizada (CAS).

@menu
* Instalaci�n::      C�mo instalar giac/cas/xcas
* Xcas::             Describe la interface de usuario de xcas
* Giac::             C�mo programar en C++ usando giac
* Ejemplos::         Algunos ejemplos de script para xcas y programacion en C++ usando giac
* Indice de conceptos:: Indice
@end menu

@node Instalaci�n, Xcas, Top, Top
@chapter Instalando giac
@menu
* Binarios::         Instalando s�lo los binarios de xcas
* Requerimientos::   librer�as y programas que necesitas
* Opciones::         librer�as opcionales que mejoran el funcionamiento de giac
* Configuraci�n::    Opciones para el script de configuraci�n del shell
* Compilaci�n::      Compilaci�n de giac
* Problemas::        Algunos trucos si tienes problemas
@end menu

@node Binarios, Requerimientos, Instalaci�n, Instalaci�n
@section Instalando los binarios
Si quieres usar @code{xcas/giac} como cualquier otro CAS y tu Sistema Operativo es
Intel x86 GNU/Linux o Intel StrongARM GNU/Linux o Windows 9x, entonces
no te tienes que preocupar de la compilaci�n. En vez de ello, puedes instalar
binarios precompilados:
@itemize
@item x86 GNU/Linux como usuario normal:
@uref{ftp://fourier.ujf-grenoble.fr/pub/hp48/xcas_user.tgz}

Descomprime el archivo con
@command{tar xvfz xcas_user.tgz}

despu�s
@command{cd xcas}

y
@command{./xcas}
@item x86 GNU/Linux si tienes acceso como root:
@uref{ftp://fourier.ujf-grenoble.fr/pub/hp48/xcas_root.tgz}
Descomprime el archivo desde el directorio @code{/}
@item ARM GNU/Linux:
@uref{ftp://fourier.ujf-grenoble.fr/pub/hp48/xcas_ipaq.tgz}
@item Windows 9x:
@uref{ftp://fourier.ujf-grenoble.fr/pub/hp48/xcas.zip}

Ejecuta @code{xcas} desde el directorio donde descomprimiste @code{xcas}.
@end itemize

@node Requerimientos, Opciones, Binarios, Instalaci�n
@section Requerimientos
Necesitas un compilador de C++ que entienda la norma C++ ANSI 3. Por
ejemplo @code{gcc} versi�n 2.95 o superior, funcionar�. Adem�s, debes
comprobar que tienes instalada la librer�a GMP GNU Math Precision.
Si no est� instalada, debes compilar e instalar la fuente:
est� disponible en cualquier mirror ftp de GNU, mira en
@uref{http://www.gnu.org} para mas detalles. Si est�s usando GNU/Linux,
la librer�a GMP es muy probable que est� instalada, pero las cabeceras
puede que no, busca un paquete llamado algo as� como @code{gmp-devel}.

@node Opciones, Configuraci�n, Requerimientos, Instalaci�n
@section Opciones
@enumerate
@item Si quieres funciones num�ricas deber�as instalar la Gnu Scientific
Library, disponible en @uref{http://sources.redhat.com/gsl}
@item Si quieres usar NTL para algunas operaciones polin�micas (actualmente
factorizaci�n), consigue la versi�n >= 5.2 en @uref{http://www.shoup.net}. Adem�s
comprueba que configuraste con permiso namespace(esto no est� por defecto)
y GMP permitido (no est� por defecto, pero tampoco es obligatorio)
Si no est�s seguro de tu instalaci�n vete al directorio del NTL y teclea
@smallexample
 make clean
 ./configure NTL_GMP_LIP=on NTL_STD_CXX=on
 make
 make install
@end smallexample
@item Si quieres funciones aritm�ticas avanzadas, consigue PARI en
@uref{http://www.parigp-home.de}.
Si te planteas usar PARI SIN NTL entonces DEBES HACER LOS
SIGUIENTES CAMBIOS en el directorio fuente de PARI:
@itemize
@item Archivo @code{src/basemath/polarit2.c}: quita la palabra
@code{static} de la declaraci�n:
@smallexample
  static GEN
  combine_factors(...)
@end smallexample
@item Archivo @code{src/headers/paridecl.h}: A�ade la l�nea

@code{GEN     combine_factors(GEN a, GEN famod, GEN p, long klim, long hint);}

en la secci�n @code{* polarit2.c}
@item Recompila (@command{make all}) y reinstala PARI (@code{make install})
y comprueba que la librer�a @code{libpari.a} ha sido actualizada o copiala explicitamente
desde el directorio @code{O<your_os>}
@item Cambia en @code{/usr/local/include/pari/pariinl.h} @code{labs}
por @code{std::abs} si no podr�as tener errores con el compilador.
@end itemize
Comprueba en el directorio src, el fichero pari.cc que la memoria reservada
a la pila de PARI se ajusta a tus necesidades (por defecto son 10MB de RAM) o modifica:
@code{  long pari_mem_size=10000000;}

@item Si quieres tener GUI (Interface Gr�fica de Usuario), comprueba que tienes FLTK 1.0 (o FLNX)
instalado (disponible en @uref{http://www.fltk.org}). Adem�s puedes obtener
modificaciones del FLTK 1.0.11 desde
@uref{http://www-fourier.ujf-grenoble.fr/~parisse/fltkpar.tgz}
esto a�ade auto-selecci�n de parentesis.
ATENCION: Actualmente @code{xcas} no funciona con FLTK 1.1.
Para el editor de matrices / hoja de c�lculo, necesitar�s adem�s FLVW
@uref{http://flvw.sourceforge.net/}


@item TeXmacs ofrece interface para giac. Puedes obtener TeXmacs en
 @uref{http://www.texmacs.org}.
Despu�s de instalar giac, ejecuta texmacs y usa Insert->Session->giac.

@end enumerate

@node Configuraci�n, Compilaci�n, Opciones, Instalaci�n
@section Opciones de configuraci�n
El script del shell @code{./configure } reconoce las siguientes opciones:
@enumerate
@item --enable-debug
  Permite imprimir vectores y a�ade codigo de depuraci�n
@item --enable-fltk
  Soporte para GUI
@item --enable-gsl
  Usa la librer�a Gnu Scientific Library para coma flotante (p.e. funciones especiales ..)
@item --enable-sscl
  Permite la inclusi�n de c�digo para algoritmos semi-cl�sicos (producto Moyal, ...)
  No disponible a�n
@item --enable-ntl
  Permite la inclusi�n de c�digo NTL
@item --enable-pari
  Permite la inclusi�n de c�digo PARI
@end enumerate

Estas opciones pueden ser desactivadas usando @code{--disable-option-name} en lugar de
@code{--enable-option-name}. Por defecto @code{configure} usar� estas opciones
si las librer�as est�n disponibles en tu sistema.

Para binarios de gran velocidad, antes de ejecutar @code{configure} haz (con bash
como shell)

@command{$ export CXXFLAGS="-O3 -fexpensive-optimizations -malign-loops=2 -malign-jumps=2 -malign-functions=2"}

o (con tcsh como shell)

@command{$ setenv CXXFLAGS "-O3 -fexpensive-optimizations -malign-loops=2 -malign-jumps=2 -malign-functions=2"}


@node Compilaci�n, Problemas, Configuraci�n, Instalaci�n
@section Compilaci�n
Como con cualquier software GNU autoconfigurable, puedes teclear:

@command{ ./configure }

[a�ade opciones necesarias: prueba @command{./configure -help} para obtener mas informaci�n]

@command{ make }

@command{ make check }

[pasa a ser root si es necesario]

@command{ make install }

Trucos:
@itemize
@item Si tienes permiso de escritura en @code{/usr/local/},
FLTK y GSL instalados y no quieres capacidad de depuraci�n, puedes teclear

@command{ ./inst}

@item Si tienes FLTK y GSL instalados y quieres capacidad de depuraci�n, teclea

@command{ ./setup}

[hazte root]

@command{ make install}

@item Si no quieres optimizaci�n, cambia la variable de entorno
@env{CXXFLAGS} a @code{-g} antes de ejecutar configure, con tcsh
@command{ setenv CXXFLAGS -g}, con bash @command{export CXXFLAGS=-g}.

@item Si quieres construir xcas para el procesador ARM con la distribuci�n
de Linux Familiar (p.e. para un iPaq @uref{http://www.handhelds.org})
asumiendo que tienes instalado skiff toolchain y FLTK. Comprueba
que  @code{config.h} define HAVE_LIBFLTK y no define
HAVE_LIBGSL y HAVE_LIBGSLCBLAS a menos que tengas estas librer�as tambi�n, entonces

@command{ make -f Makefile.ipaq}

N�tese que nunca he conseguido construirlo con optimizaci�n para el iPaq.

@item Si quieres el cas s�lo en l�nea de comandos, ejecuta

 @command{ ./configure --disable-gui}

 @command{ make }

@item Windows

Puedes compilar la versi�n librer�a de giac bajo Unix.
O asumiendo que tengas las herramientas cygwin, gmp y FLTK instaladas (mira en
@uref{http://sources.redhat.com/cygwin} para cygwin, ejecuta cygwin,
vete al directorio @code{src} y ejecuta

@command{ make -f Makefile.win}

Despu�s de esto, puedes ejecutar @code{xcas.exe} de forma independiente,
@code{/usr/bin/cygwin1.dll} proporcionada ha sido copiada en el path (p.e. en el mismo
directorio que @code{xcas.exe})
@end itemize


@node Problemas, , Compilaci�n, Instalaci�n
@section Problemas
@itemize
@item Si compruebas giac despu�s de la compilaci�n con @code{make check},
por favor nota que la respuesta asume que PARI y NTL no est�n permitidos (enabled).
Si no obtendr�s algunos errores porque la factorizaci�n no
devolver� los factores en el mismo orden.
@item Optimizaci�n requiere mucha memoria para compilar. Si est�s bajo
de memoria edita @code{src/Makefile} y si es necesario cambia la l�nea :

@code{CXXFLAGS = -g -O2}
por :

@code{CXXFLAGS = -g}
@item Ha sido imposible compilar FLTK con gcc 3. Instala  2.95 o 2.96
o reconfigura sin soporte FLTK o compila solo la versi�n de l�nea de comandos
de giac
@item Si tienes un error como

@command{autoheader: Symbol 'CONSTANT_DEBUG_SUPPORT' is not covered by ...}

ejecuta

@command{autoheader --localdir=.}
@item Si obtienes un error compilando @code{modpoly.cc}, es casi seguro
porque compilaste sin NTL namespaces. Recomp�lalo (vease secci�n)
@item Si obtienes un error de uni�n sobre combine_factors no encontrados en
@code{modfactor.o} ser� porque no modificaste PARI correctamente u
olvidaste reinstalar las librer�as de PARI (vease secci�n)
@item La compilaci�n con Cygwin de Giac con PARI 2.1.1 requiere que hagas
algun trabajo manual. No he podido compilar la versi�n din�mica de la librer�a PARI.
Por lo tanto tuve que hacer la instalaci�n a mano
@smallexample
cp libpari.a /usr/local/lib
mkdir /usr/local/include/pari
cp src/headers/*.h /usr/local/include/pari
cp Ocygwin/*.h /usr/local/include/pari
@end smallexample
Entonces obtuve un error compilando @code{pari.cc} que desapareci�n comentando
la l�nea causante en la cabecera @code{/usr/local/include/pari/paricom.h}
Despu�s de esto todo fu� correctamente.
@end itemize

@node Xcas, Giac, Instalaci�n, Top
@chapter Usando xcas, una interface de usuario con giac
@code{xcas} es una interface de usuario con giac que es similar a una calculadora.
Una interface de l�nea de comandos llamada @code{cas} tambi�n est� disponible.

@menu
* Interface::
* CAS::
* Geometr�a::
* Scripting::
@end menu

@node Interface, CAS, ,Xcas
@section La interface
Puedes usar, pero no lo necesitas, un teclado puesto que esta interface
est� dise�ada para ser usada tambi�n en PDA. Usa el bot�n verde cambio para obtener
los botones del teclado.

La ventana est� compuesta de izquierda a derecha y de arriba a abajo por:
@enumerate
@item La barra principal de men�s
@item El historial o ventana gr�fica
@item La barra de herramientas del historial y el menu de Edici�n/dibujo
@item la l�nea de comandos
@item La barra de men�s por teclas (como en las calculadoras gr�ficas HP4x)
@item Ayuda en l�nea
@item Botones tipo calculadora a la derecha
@end enumerate

La interface se asemeja a las avanzadas calculadoras gr�ficas (TI89, TI92,
HP49G en modo algebraico): escribes un comando en la l�nea de comandos
con la ayuda del teclado y/o los botones, ayuda en l�nea y men�s.
Entonces pulsando Enter se evaluar� tu expresi�n y devolver� el
resultado al �rea del historial. Si un comando devuelve un objeto gr�fico
la ventana historial ser� reemplazada por la ventana gr�fica. Puedes
cambiar de ventana historial a gr�fica usando el bot�n @code{Geo}
en la barra de men�s por teclas.

La ayuda en l�nea da una breve descripci�n de todos los comandos del CAS
con ejemplos que pueden ser pegados en la l�nea de comandos. Est� disponible
por defecto en @code{xcas} o con el comando @code{aide} desde shell.

Imprimir requiere una instalaci�n operativa de @code{LaTeX} con @code{pstricks}.

@node CAS, Geometr�a, Interface, Xcas
@section Comandos del sistema de �lgebra computerizado
Una lista de comandos del CAS.
@menu
* Men� matem�ticas::
* Aritm�tica::
* Men� del CAS::
* Algebra lineal::
@end menu

@node Men� matem�ticas, Aritm�tica, , CAS
@subsection Comandos matem�ticos b�sicos

@node Aritm�tica, Men� del CAS, Men� matem�ticas, CAS
@subsection Aritm�tica de enteros y polin�mios
Los comandos  @code{gcd}y @code{lcm} se aplican a ambos tipos de argumentos:
devuelven el m�ximo com�n divisor o el m�nimo com�n m�ltiplo.
Otros comandos aritm�ticos deben comenzar con la letra @code{i} si quieres usarlos
con enteros, si no los argumentos ser�n considerados como polin�mios constantes.
@menu
* Aritm�tica de enteros::
* Aritm�tica de polin�mios::
@end menu

@node Aritm�tica de enteros, Aritm�tica de polin�mios, , Aritm�tica
@subsubsection Fucniones artim�ticas de enteros
@menu
* Divisi�n::      Divisi�n eucl�dea
* Mcd::             Mcd, Mcm, Mcd extendido, restos chinos
* Primalidad::     Test de primalidad, factorizaci�n, caracter�stica de Euler
* Otros enteros:: Jacobi, s�mbolo de Legendre ...
@end menu

@node Divisi�n, Mcd, , Aritm�tica de enteros
@subsubsection Divisi�n eucl�dea entera
Dados dos enteros  @code{a} y  @code{b}, la divisi�n eucl�dea entera
est� definida por la igualdad :
@example
a=b*q+r
@end example
donde normalmente  @code{r} se coge entre  0 y @code{b-1}, o
en la representaci�n sim�trica , entre @code{-b/2} y @code{b/2}.
Las funciones  @code{iquo(a,b)} y  @code{irem(a,b)} devuelven respectivamente
@code{q} y @code{r}, o @code{iquorem(a,b)} devueltas ambas como un vector.
La funci�n @code{smod(a,b)} devolver� @code{r} usando el convenio de resto
sim�trico.

@node Mcd, Primalidad, Divisi�n, Aritm�tica de enteros
@subsubsection Mcd de enteros
la funci�n @code{gcd(a,b)} devuelve el m�ximo com�n divisor (Mcd)
@code{d} de dos enteros @code{a} y  @code{b}. Si necesitas dos enteros
@code{u} y @code{v} tales que:
@example
a*u+b*v=d
@end example
puedes usar en su lugar @code{egcd(a,b)} , devolver�  @code{[u,v,d]}.

El comando  @code{ichinrem([a,n],[b,m])} donde @code{n} y @code{m}
son primos devolver� un vector @code{[c,n*m]} tal que
@code{c=a (mod n)} y  @code{c=b (mod m)}.

@node Primalidad, Otros enteros, Mcd, Aritm�tica de enteros
@subsubsection Primalidad y factorizaci�n
La funci�n @code{is_prime(a)} devolver� 0 si @code{a} no es primo.
Devolver� 2 si @code{a} es seguro primo, y 1 si @code{a}
es pseudo-primo. Si has compilado @code{xcas} con soporte PARI,
obtendr�s un certificado de primo en su lugar (v�ase documentaci�n de PARI
para m�s informaci�n).

Los comandos  @code{nextprime(a)} y  @code{prevprime(a)} devolver�n
el siguiente o anterior (pseudo-)primo, de un entero @code{a} dado.

La funci�n @code{ifactor(a)} devuelve la factorizaci�n de @code{a}.
Es una buena idea compilar con soporte PARI si tienes planeado factorizar
enteros relativamente grandes (con factores primos de mas de 20 d�gitos).

@node Otros enteros, , Primalidad, Aritm�tica de enteros
@subsubsection Otras funciones enteras (Legendre, Jacobi, ...)
Funciones de enteras adicionales provistas por  @code{xcas} son
@itemize
@item @code{jacobi(a,b)}
y  @code{legendre(a,b)}, v�ase la documentaci�n de  GMP para m�s detalles.
@item @code{pa2b2(p)} devuelve  @code{[a,b]} tal que @code{p=a*a+b*b}
si @code{p=1 (mod 4)} es primo.
@end itemize

@node Aritm�tica de polin�mios, , Aritm�tica de enteros, Aritm�tica
@subsubsection Funciones aritm�ticas de polin�mios
Los polin�mios tienen dos representaciones: representaci�n simb�lica o
por un vector de coeficientes. En la representaci�n simb�lica puedes
a�adir el nombre de la variable como par�metro adicional a las funciones
que uses, si no la variable por defecto ser� la usada. Para la representaci�n
por vector, es recomendable usar el delimitador correcto @code{poly1[}
en lugar de @code{[} con  lo que las operaciones habituales (suma,..)
se comportar�n correctamente (no como si fuesen vectores o matrices).
@enumerate
@item @code{quo(a,b)} @code{rem(a,b)} y @code{quorem(a,b)}
devuelven respectivamente los polin�mios @code{q}, @code{r} y  @code{[q,r]}
tales que  @code{a=b*q+r} y @code{degree(r)<degree(b)}
@item @code{gcd(a,b)} devuelve el m�ximo com�n divisor de dos polin�mios
@item @code{egcd(a,b)} es el algor�tmo Mcd ecl�deo extendido, al igual que para
enteros devuelve una lista de 3 polin�momios  @code{u,v,d} tales que  @code{au+bv=d}.
@item @code{chinrem} devuelve el resto chino para polin�mios escritos como listas.
Los 2 argumentos son dos listas hechas de polin�mios m�dulo otro polinomio
 (donde los polin�mios m�dulo son primos entre ellos).
La respuesta es el polin�mio m�dulo producto de los polin�mios m�dulo
que reduce a los originales polin�mios m�dulo los originales polin�mios m�dulo
@item @code{cyclotomic} toma un entero n como argumento y devuelve el polin�mio
ciclot�mico n-�simo.
@end enumerate

@node Men� del CAS, Algebra lineal, Aritm�tica, CAS
@subsection Algebra, calculo, ...
@menu
* Reescribiendo::
* Diferenciales e integrales::
* Limites y series::
* Resolviendo ecuaciones::
* Otras funciones del cas::
@end menu

@node Reescribiendo, Diferenciales e integrales, , Men� del CAS
@subsubsection Reescribiendo expresiones
El comando @code{normal} reescribe una fracci�n racional como una relaci�n
entre dos polin�mios coprimos. Si una expresi�n no es racional, primero es
racionalizada sustituyendo las expresiones transcendentales (p.e.
@code{sin(x)} ) por un identificador temporal. Expresiones algebraicas
(p.e. @code{sqrt(x)}) tambi�n son  normalizadas.

El comando @code{factor} factoriza polin�mios. Como antes, expresiones
no polin�micas son racionalizadas primero. Puedes elegir la variable
b�sica respecto a la cual el polin�mio ser� factorizado a�adiendola como
segundo argumento a  @code{factor}.

La funci�n @code{texpand} es usada para expandir expresiones
transcendentales como @code{exp(x+y)=exp(x)*exp(y)} o reglas similares
para funciones  trigonom�tricas. La funci�n  @code{tlin} realiza
la operaci�n inversa para funciones trigonom�tricas , tal y como la funci�n
@code{lin} lo hace para las exponenciales.

La funci�n  @code{halftan} reescribe expresiones trigonom�tricas
en t�rminos de la tangente del �ngulo mitad. La funci�n  @code{hyp2exp}
reescribe funciones hiperb�licas en t�rminos exponenciales.

@node Diferenciales e integrales, Limites y series, Reescribiendo, Men� del CAS
@subsubsection Derivaci�n, integraci�n
La instrucci�n para diferenciaci�n es @code{diff(expression,variable)}.
La antiderivada indefinida se obtiene usando
@code{integrate(expression,variable)}. Si necesitas integraci�n definida
entre los l�mites @code{a} y @code{b}, escoge
@code{integrate(expression,variable,a,b)} para integraci�n exacta
o @code{romberg(expression,variable,a,b)} para integraci�n num�rica.

Un ejemplo de integraci�n definida son los coeficientes de Fourier de funciones
peri�dicas. Son obtenidos usando @code{fourier_an} y @code{fourier_bn}
para coeficientes trigonom�tricos o usando @code{fourier_cn} para
coeficientes exponenciales complejos.

Algunas antiderivadas discretas pueden ser obtenidas usando
@code{sum(variable,expression)} .

@node Limites y series, Resolviendo ecuaciones, Diferenciales e integrales, Men� del CAS
@subsubsection L�mites, desarrollos en serie.
Para un l�mite la sint�sis es
@code{limit(expression,variable,limitpoint[,direction])}.
Para un desarrollo en serie
@code{series(expression,variable,limitpoint,order[,direction])}.
La implementaci�n en @code{giac} de @code{limit} y @code{series} est�
basada en el algor�tmo mrv.

@node Resolviendo ecuaciones, Otras funciones del cas, Limites y series, Men� del CAS
@subsection Resolviendo ecuaciones
Usando @code{solve(expression,variable)} se busca la soluci�n exacta
de ecuaciones polin�micas. Usa @code{newton} para soulciones
num�ricas (de un mayor rango de ecuaciones).

@node Otras funciones del cas, , Resolviendo ecuaciones, Men� del CAS

@node Algebra lineal , , Men� del CAS, CAS
@subsection Algebra lineal
Las operacions aritm�ticas sobre matrices y vectorse se hacen usando los operadores
habituales. El producto escalar de 2 vectores se obtiene usando el operador  @code{*}.

La eliminaci�n Gaussiana sobre una matriz  (Gauss-Bareiss) se desarrolla
usando  @code{rref(m)}. El n�cleo de una aplicaci�n lineal de matriz m
se obtiene con  @code{ker(m)}. Un sistema de ecuaciones lineales (escrito
simb�licamente como un vector) puede ser resuelto con
@code{linsolve([equations],[variables])}.

El determinante de una  matriz puede ser obtenido usando dos algor�tmos,
o bien  Gauss-Bareiss usando  @code{det(m)}, o calculando los menores
@code{det_minor(m)}. Realmente, un �ltimo m�todo est� disponible usando
el c�lculo de los coeficientes constantes del polin�mio caracter�stico usando
el algor�tmo Fadeev-Leverrier.

El polin�mio caracter�stico de una matriz puede ser calculado por el algor�tmo de
Fadeev-Leverrier usando  @code{pcar(m)}. Para matrices con los coeficientes en
un campo finito, @code{pcar_hessenberg(m)} es una mejor opci�n  (complejidad
@code{O(n^3)} donde @code{n} es el tama�o de la matriz).

Los valores propios y los vectores propios son calculados usando respectivamente
@code{egvl(m)} y @code{egv(m)}. La forma normal de Jordan se obtiene usando
@code{jordan(m)}.

La formas cuadr�ticas  (escritas simb�licamente) pueden ser reducidas a sumas
y diferencias de cuadrados usando  @code{gauss(expression,[variables])}.

Hay alg�n soporte para isometr�as: @code{mkisom} puede ser usado para
hacer una isometr�a  desde sus propios elementos y @code{isom(m)} devuelve
los elementos propios de una isometr�a.

@node Geometr�a, Scripting, CAS, Xcas
@section Geometr�a
Como cualquier otro objeto, puedes crear objetos geom�tricos usando la
l�nea de comandos. Adicionalmente, si la ventana gr�fica est� activa (clicka
en el bot�n  @code{Geo} si es  necesario), puedes crear puntos y
segmentos con el rat�n (o el l�piz apuntador) o mover un objeto geom�trico.
Para crear un punto,simplemente clicka. Para crear una l�nea, pulsa cualquier bot�n
del rat�n, mueve el rat�n y suelta el bot�n en el segundo punto.
Para mover un objeto, primero selecci�nalo clickando cerca de �l. La l�nea de comandos
deber� mostrar el nombre del objeto. Puedes moverlo pulsando el rat�n
cerca del objeto y movi�ndolo. Suelta el bot�n del rat�n en la posici�n
final. Puedes cancelar un movimiento soltando el rat�n fuera de la ventana
gr�fica. Como en cualquier paquete de geometr�a din�mica. todos los objetos dependientes
de un objeto, se mover�n cuando muevas dicho objeto.

Para imprimir el gr�fico actual, puedes usar la instrucci�n @code{graph2tex()}
o bien, sin argumentos (entonces el c�digo @code{LaTeX} ser� insertado en su lugar
en el historial) o con una cadena de texto conteniendo el nombre
del fichero donde se guardar� una versi�n aislada del gr�fico, por ejemplo
@code{graph2tex("figure.tex")} crear� un fichero llamado @code{figure.tex}
que podr�s compilar con @code{latex figure.tex}.

@node Scripting, , Geometr�a, Xcas
@section El lenguaje script de xcas
Xcas y el programa cas proveen un lenguaje interpretado similar a
otros populares lenguajes de programaci�n de CAS. Este lenguaje scrip est�
disponible en 3 formas: sint�xis similar a C (por defecto) o en modo compatibilidad
para programas simples de Maple o Mupad. Describiremos s�lo la sint�xis similar a C.
Las instrucciones deben acabar con punto y coma @code{;}. Los grupos de
instrucciones pueden ser combinados usando llaves, como en C.

@menu
* Modo del lenguaje::
* Datos::
* Bucles y condicionales::
* Funciones::
@end menu

@node Modo del lenguaje, Datos, , Scripting
@section Selecci�n del modo del lenguage
El comando @code{maple_mode(0)} o @code{maple_mode(1)} o
@code{maple_mode(2)} puede ser usado para cambiar la forma del lenguaje
respectivamente entre modo similar-C a similar-Maple o similar-Mupad. N�tese que este
comando tiene efecto s�lo cuando la sesi�n actual del interprete finaliza
lo que significa cuando el siguiente comando sea procesado en modo interactivo o
al finalizar el fichero de proceso por lotes actual, por lo tanto no deber�as comenzar un script
con este comando. En modo de proceso por lotes puedes cambiar el modo activando la
variable de entorno @code{MAPLE_MODE}, por ejemplo con
tcsh: @command{setenv MAPLE_MODE 1}
o con bash @command{export MAPLE_MODE=1}
cambiar� a lenguaje similar a Maple. O puedes ejecutar @code{maplec} o
@code{mupadc} en vez de @code{cas}. Adicionalmente puedes introducir
el comando @code{maple_mode(1)} en el @code{.xcasrc} de tu directorio ra�z
para cambiar el comportamiento por defecto. O dentro de @code{xcas} puedes ejecutar
el comando @code{Import} del men� @code{File} y seleccionar la forma.
El comando @code{Export} puede ser usado para traducir el nivel actual
del historial dentro de @code{xcas} a un fichero, o el comando @code{View as}
del men� @code{Edit} para traducirlo a la ventana de salida de la ayuda.

@node Datos, Bucles y condicionales, Modo del lenguaje, Scripting
@section Datos
El lenguaje acepta variables locales y globales, variables no son tecleadas.
Las variables globales no necesitan ser declaradas, las locales deben ser declaradas
al principio de una funci�n por la palabra clave @code{local} seguido de
los nombres de las variables locales separados por comas @code{,} con punto y coma
final @code{;}

El signo de asiganci�n es @code{:=} como en CAS populares y distinto a C.
Otras operaciones (p.e. @{+ - * /@}) y llamadas a funciones son hechos como en C
o como en una sesi�n interactiva.
Como en C, para comprobar igualdad se usa @code{==}. El signo de igual simple @code{=}
se usa para devolver una ecuaci�n (esta ecuaci�n ser� comprobada como un test
s�lo en algunas situaciones donde una ecuaci�n no es esperada).
Las otras cl�usulas de test son @code{!=} para distinto, @code{< <= > >=} para
comparaciones de valores relaes. Puedes combinar tests con  @code{&&} o @code{and},
y @code{||} o @code{or}. La negaci�n booleana es @code{!} o @code{not}.

@node Bucles y condicionales, Funciones, Datos, Scripting
La palabra clave para bucles es como en C

@command{for (inicializacion;mientras_condition;incremento)@{ bloque_bucle @}}

Puedes romper un bucle dentro de la iteraci�n con @code{break;}.
Puedes saltar immediatamente a la siguiente iteraci�n con @code{continue;}.

Las palabras clave para condicionales son como en C

@command{if (condicion) @{ bloque_si_cierto @} [ else @{ bloque_si_falso @} ]}

Adicionalmente, la selecci�n m�ltiple es traducida como en C

@command{swith (variable)@{ case (valor_1): ... break; default: ... ; @} }

@node Funciones, , Bucles y condicionales, Scripting
Las funciones son declaradas e implementadas juntas de esta manera

@command{nombre_funcion(parametros):=@{ definicion @}}

Los par�metros son como variables locales con una inicializaci�n adicional
de los valores de los par�metros dentro de la funci�n.

El @code{return(valor_retorno)} debe ser usado pra devolver el valor
de la funci�n.

No es posible pasar argumentos por referencia, s�lo por valor.

Una vez que una funci�n es definida, un fichero llamado @code{nombre_funcion.cas}
es generado en el directorio actual. Una buena idea es agrupar
definiciones de funciones correspondientes con el mismo tema en un fichero
llamado con una extensi�n @code{.cc} (de esta manera la identaci�n similar a C
ocurre autom�ticamente cuando editas el fichero con tu editor favorito) y
"compila" este fichero con
@command{cas ccnombrefichero.cc}
o dentro de @code{xcas} con el comando @code{Run file} del men� @code{Files}.

Una vez que una funci�n est� definida, si modificas el correspondiente fichero @code{.cas},
no afectar� a la definici�n de la funci�n correspondiente durante la
sesi�n actual.

@node Giac, Ejemplos, Xcas, Top
En este cap�tulo primero describiremos el tipo de dato gen�rico de giac,
la clase @code{gen}. Despu�s describiremos los tipos de datos m�s importantes
que @code{gen} cubre (polin�mios, vectores, objetos simb�licos
y funciones unarias de gen). En este punto, el lector deber�a ser
capaz de programar usando @code{giac}, por lo tanto describimos como integrar
c�digo a @code{giac} por inclusi�n en la librer�a o como una librer�a
ejecutable separada (llamada m�dulo). el �ltimo punto describe
como puedes a�adir nuevos objetos matem�ticos, p.e. quaternas,
dentro del tipo @code{gen}.

@menu
* C++::                             Por qu� escogimos C++
* Gen::                             La clase gen�rica usada en todo giac
* Polin�mios::                      Polin�mios.
* Vectores y matrices::             Vectores y matrices.
* Simb�licos::                      Simb�licos.
* Funciones unarias::               Funciones que toman un gen y devuelven un gen
* Haciendo una funcion libreria:: A�ade funcionalidades a giac
* Haciendo modulos::                A�ade funciones cargables din�micamente a giac
* Datos definidos por usuario::  Define your own data inside giac
@end menu

@node C++, Gen, , Giac
Giac usa el lenguaje C++ porque es m�s f�cil escribir operaciones
algebraicas usando operadores habituales, por ejemplo @code{a+b*x} es m�s f�cil
de entender y modificar que @code{add(a,mul(b,x))}, pero no es necesario
que aprendas programaci�n orientada a objetos. De hecho, es m�s una
librer�a de C usando caracter�sticas de C++ que facilitan la programaci�n easier (como las
secuencias I/O y la librer�a de plantillas estandard). De todos modos necesitar�s
un compilador de C++ reciente, p.e. @code{gcc} versi�n 2.95 o posterior.


@node Gen, Polin�mios, C++, Giac
@chapter La clase gen
@cindex gen

@code{gen} es la clase usada para representar objetos matem�ticos
(@code{#include <giac/gen.h>}). Es una uni�n en C, hecha bien de obejtos ``directos''
como @code{int} o @code{double}
o de punteros al mont�n de objetos afectados que est�n referenciados.
La reserva de memoria la realiza la propia librer�a (salvo
tipos de objetos definidos por el usuario). Puedes comprobar
el tipo actual de una variable de tipo @code{gen}, p.e. @code{gen e;},
usando su campo @code{type} (p.e. @code{if (e.type==...)}). Este
campo @code{type} de un @code{gen} es un @code{int}.

El @code{gen} podr�a ser~:
@enumerate
@item un entero inmediato (@code{e.type==_INT_})
@item un real (double) (@code{e.type==_REAL})
@item un entero de precision arbitraria (@code{e.type==_ZINT})
@item un n�mero complejo (@code{e.type==_CINT}), un puntero a
dos objetos de tipo @code{gen} la parte real y la parte imaginaria
@item un nombre global (@code{e.type==_IDNT}), con un puntero a un
tipo @code{identificateur}
@item un objeto simb�lico (@code{e.type==_SYMB}), con un puntero a
tipo @code{symbolic}
@item un objeto vector (de hecho es una lista) (@code{e.type==_VECT}),
con un puntero a un tipo @code{vecteur}
@item un objeto funci�n (@code{e.type==_FUNC}),
con un puntero a un tipo @code{unary_function_ptr}
@end enumerate

Otros tipos est�n disponibles (p.e. un puntero a un objeto @code{gen_user}
que puedes derivar para hacer tus propias clases, o n�meros de coma flotante
con precision arbitraria que ser�n implementados m�s tarde), para una descripci�n
completa mira en @code{giac/gen.h} (si tienes instalado @code{giac}
la ruta a los ficheros incluidos es @code{/usr/local/include/giac} a menos que
invalide la que est� por defecto, si no lo instalas, la ruta es la ruta al
directorio @code{src} de la distribuci�n del c�digo fuente).

Si quieres acceder al tipo subyacente, despues de comprobar que el tipo
es correcto, puedes hacer lo siguiente:
@enumerate
@item para un entero inmediato: @code{int i=e.val;}
@item para un real (double): @code{double d=e._DOUBLE_val;}
@item para enteros de precisi�n arbitraria: @code{mpz_t * m=e._ZINTptr;}
@item para n�meros complejos: @code{gen realpart=*e._CINTptr; }
@item para identificadores: @code{identificateur i=*e._IDNTptr; }
@item para simb�licos: @code{symbolic s=*e._SYMBptr;}
@item para compuestos: @code{vecteur v=*e._VECTptr;}
@item para objetos funci�n: @code{unary_function_ptr u=*e._FUNCptr}
@end enumerate

Adem�s del @code{type} principal, cada @code{gen} tiene @code{subtype} (subtipo).
Este subtipo se usa algunas veces para seleccionar diferentes comportamientos, p.e.
a�adiendo una constante a un vector podr�a a�adir la constante a todos los t�rminos
para algunos obejtos geom�tricos representados usando vectores, s�lo a los t�rminos
de la diagonal de la matriz cuadrada, o al �ltimo t�rmino de polin�mios densos.
Mira en @code{giac/dispatch.h} la descripci�n de los subtipos.

@node Polin�mios, Vectores y matrices, Gen, Giac
@cindex Polin�mios
@section Polin�mios
Polin�mios est�n disponibles como:
@itemize
@item polin�mios multivariables escasos @code{polynome}, los
ficheros de cabecera son @code{gausspol.h} y @code{poly.h}
@item polin�mios univariables densos: @code{poly1} o alias @code{modpoly}
usado para polin�mios univariables modulares. El tipo usado es el mismo
que para vectores y matrices.
Los ficheros de cabecera son @code{giac/polygauss.h} y @code{giac/modpoly.h}.
@end itemize

Un @code{gen} puede ser un polin�mio si su campo @code{type} es
respectivamente @code{_POLY} (escaso) o @code{_VECT} (denso).
Las funciones de conversi�n a y de la representaci�n simb�lica
respecto a nombres globales son declaradas en @code{giac/sym2poly.cc}.

@node Vectores y matrices, Simb�licos, Polin�mios, Giac
@cindex Vectores
@cindex Matrices
@section Vectores y matrices
El tipo usado para vectores y matrices es el mismo, es un
@code{std::vector<gen>} (a menos que lo tengas configurado con
@code{--enable-debug}). El fichero cabecera es @code{giac/vecteur.h}.
Un @code{gen} puede ser un vector si su campo @code{type} es
@code{_VECT}.

@node Simb�licos, Funciones unarias, Vectores y matrices, Giac
@cindex Simb�licos
@section Simb�licos
Los objetos simb�licos son �rboles. El @code{sommet} es una @code{unary_function_ptr}
(una clase apuntando a una funci�n). El @code{feuille} es tambi�n
un @code{gen} at�mico (para un funci�n con un argumento) o un compuesto
(@code{feuille.type==_VECT}) para una funci�n con m�s de un argumento
(estas funciones aparecen por lo tanto como una funci�n con un argumento el cual
es la lista de todos sus argumentos).

@node Funciones unarias, Haciendo una funcion libreria, Simb�licos, Giac
@cindex Funciones unarias
@section Funciones unarias
En la librer�a giac, cada funci�n es vista como un funci�n que coge un
argumento y devuelve un argumento. Si una funci�n debiese tener m�s de un
argumento, metemos estos argumentos en un vector.

Los ficheros @code{usual.cc/.h} dan ejemplos de declaraciones p.ej. para
funciones exponenciales y trigonom�tricas. Las funciones unarias tienen
los siguientes miembros~:
@itemize
@item una funci�n que coge un @code{gen} y devuelve un @code{gen}
que hace todo el trabajo
@item derivadas parciales de esa funci�n si existen
@item un desarrollo en serie especial de Taylor si es necesario (vease p.ej. @code{taylor_asin}).
�ste es siempre el caso si tu funci�n est� definida en infinito.
Notese que esta funci�n
es ejecutada al inicio as� que puedes incluir c�digo en ella por
ejemplo para a�adir tu funci�n al paso de preproceso simb�lico del
algor�tmo @code{limit/series} .
@item una cadena de texto identificadora para imprimir. Si quieres que el int�rprete
reconozca tu funci�n, debes a�adir una l�nea en @code{input_lexer.ll}
(mira por ejemplo @code{"sin"}) o debes registrarla (mira m�s abajo).
@item dos funciones especial de impresi�n si la impresi�n normal (impresi�n normal
significa imprimir el nombre de la funci�n seguido por el argumento(s) entre par�ntesis)
no es la forma correcta de imprimirla. Un puntero nulo significa que se usa impresi�n
normal.
@end itemize
Una vez que la @code{unaria_funcion_unaria} est� definida, debes construtir
un @code{unaria_funcion_ptr} para poder usar lo simb�licos internos.

Podr�as dar un argumento opcional para especificar un comportamiento para la evaluaci�n
de argumentos (citando). En este caso, podr�as dar un segundo argumento opcional
para registrar tu funci�n din�micamente en la lista de nombre de funciones
reconozidas por el int�rprete. Aseg�rate de unir el fichero objeto de forma
que la inicializaci�n occurre despues de inicializarse @code{input_lexer.ll},
esto significa que debes poner tu fichero objeto antes de @code{input_lexer.o}
cuando unas (mira por ejemplo la posici�n de @code{moyal.o} en
el fichero @code{Makefile.am} , @code{moyal}
es un ejemplo de registro din�mico).

Tienes, por supuesto, la opci�n de declarar el nombre de la funci�n
est�ticamente en el fichero @code{input_lexer.ll}.

Siempre debes declarar una funci�n est�ticamente si no sigue
la sint�xis est�ndar para una funci�n.

@node Haciendo una funcion libreria, Haciendo modulos, Funciones unarias, Giac
Aqu� est� un ejemplo de una funci�n unible din�micamente llamada
@code{example} que requiere 2 argumentos y devuelve la suma dividida
por el producto si los argumentos son enteros o se devuelve a si misma en otro caso.
La cabecera en C++ de @code{example.h} ser�a algo as�
@example
#ifndef __EXAMPLE_H
#define __EXAMPLE_H
#include <giac/gen.h>
#include <giac/unary.h>

#ifndef NO_NAMESPACE_GIAC
namespace giac @{
#endif // ndef NO_NAMESPACE_GIAC

  gen example(const gen & a,const gen & b);
  gen _example(const gen & args);
  extern unary_function_ptr at_example ;

#ifndef NO_NAMESPACE_GIAC
@} // namespace giac
#endif // ndef NO_NAMESPACE_GIAC
#endif // __EXAMPLE_H
@end example

El c�digo en C++ ser�a algo como:
@example
using namespace std;
#include <giac/giac.h>
#include "example.h"

#ifndef NO_NAMESPACE_GIAC
namespace giac @{
#endif // ndef NO_NAMESPACE_GIAC

  gen example(const gen & a,const gen & b)@{
    if (is_integer(a) && is_integer(b))
      return (a+b)/(a*b);
    return symbolic(at_example,makevecteur(a,b));
  @}

  gen _example(const gen & args)@{
    if ( (args.type!=_VECT) || (args._VECTptr->size()!=2) )
      setsizeerr(); // type checking : args must be a vector of size 2
    vecteur & v=*args._VECTptr;
    return example(v[0],v[1]);
  @}
  const string _example_s("example");
  unary_function_unary __example(&_example,_example_s);
  unary_function_ptr at_example (&__example,0,true);

#ifndef NO_NAMESPACE_GIAC
@}
#endif // ndef NO_NAMESPACE_GIAC
@end example

Comp�lalo con
@example
c++ -g -c example.cc
@end example

Para probar tu c�digo, podr�as escribir el siguiente @code{test.cc} programa
@example
#include "example.h"

using namespace std;
using namespace giac;

int main()@{
  gen args;
  cout << "Enter argument of example function";
  cin >> args;
  cout << "Result: " << _example(args) << endl;
@}
@end example
Comp�lalo con el comando
@example
c++ -g example.o test.cc -lgiac -lgmp
@end example
Podr�as necesitar unirlo a otras librer�as p.ej.
@code{-lreadline -lhistory -lcurses} dependiendo de tu instalaci�n.
Entonces ejecuta @code{a.out}. En este punto probar�as con p.ej. @code{[1,2]}.

Puedes depurar tu programa como siempre, p.ej. con
@code{gdb a.out}, es recomendable crear un fichero @code{.gdbinit}
en el directorio actual de forma que puedas usar el comando @code{v}
para imprimir datos de giac, el fichero @code{.gdbinit} podr�a contener :
@example
echo Defining v as print command for giac types\n
define v
print ($arg0).dbgprint()
end
@end example

Cuando tu funci�n est� comprobada, puedes a�adirla a la librer�a. Edita
el fichero @code{Makefile.am} del subdirectorio @code{src}
de @code{giac} : simplemente a�ade @code{example.cc} antes de @code{input_lexer.cc}
en la l�nea @code{libgiac_la_SOURCES} y a�ade @code{example.h} en la l�nea
@code{giacinclude_HEADERS} .

Para reconstruir la librer�a vete al directorio @code{giac} y escribe
@code{automake; make}

Si quieres compartir tu funci�n(es) con otras personas, debes
ponerle licencia GPL (porque estar� unida a c�digo GPL).
A�ade la cabecera GPL a los ficheros, y env�alos al e-mail de contribuciones de @code{giac},
actualmente @code{mailto:parisse@@fourier.ujf-grenoble.fr}
@example
/*
 *  Copyright (C) 2002 Your name
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
@end example

@node Haciendo modulos, Datos definidos por usuario,  Haciendo una funcion libreria, Giac
Otra forma de compartir tu c�digo podr�a ser construir una librer�a din�mica
que puede ser cargada en tiempo de ejecuci�n usando las facilidades de @code{<dlfcns.h>}.
ATENCION: los m�dulos no funcionan con binarios est�ticos. Aseg�rate
de tener binarios din�micos (situaci�n por defecto cuando compilas giac,
pero el paquete @code{xcas} distribuido como binario est� construido est�tico para
evitar librer�as incompatibles).

Definamos una funci�n llamada  @code{mydll} en el fichero @code{mydll.cc} como
este :
@example
#include <giac/giac.h>

#ifndef NO_NAMESPACE_GIAC
namespace giac @{
#endif // ndef NO_NAMESPACE_GIAC

  const string _mydll_s("mydll");
  gen _mydll(const gen & args)@{
    return sin(ln(args));
  @}
  unary_function_unary __mydll(&giac::_mydll,_mydll_s);
  unary_function_ptr at_mydll (&__mydll,0,true); // auto-register

#ifndef NO_NAMESPACE_GIAC
@} // namespace giac
#endif // ndef NO_NAMESPACE_GIAC
@end example

Comp�lalo como esto
@example
c++ -fPIC -DPIC -g -c mydll.cc -o mydll.lo
cc -shared  mydll.lo  -lc  -Wl,-soname -Wl,libmydll.so.0 -o libmydll.so.0.0.0
rm -f libmydll.so.0 && ln -s libmydll.so.0.0.0 libmydll.so.0
rm -f libmydll.so && ln -s libmydll.so.0.0.0 libmydll.so
@end example

La librer�a es cargable en tiempo de ejecuci�n de una sesei�n usando el comando
@code{insmod("libmydll.so")} asumiendo que est� guardada en un directorio disponible
desde @code{LD_LIBRARY_PATH} o en @code{/etc/ld.so.conf} si no
debes poner la ruta al fichero librer�a (comenzando con @code{./} si
est� en el directorio actual).

Una forma de comprobar tu c�digo es a�adir la l�nea siguiente en tu
fichero @code{~/.xcasrc}  :
@example
insmod("ruta_a_libmydll/libmydll.so");
@end example
donde cambias  @code{ruta_a_libmydll.so} por la ruta real a
@code{libmydll.so} por ejemplo @code{/home/joe} si tu nombre de conexi�n (login) es
@code{joe} y @code{mydll} est� en tu directorio home.
Entonces si est�s usando como editor @code{emacs} , pon como primera l�nea del
fichero @code{mydll.cc}
@example
// -*- mode:C++ ; compile-command: "g++ -I.. -fPIC -DPIC -g -c mydll.cc -o mydll.lo && ln -sf mydll.lo mydll.o && gcc -shared mydll.lo -lc  -Wl,-soname -Wl,libmydll.so.0 -o libmydll.so.0.0.0 && ln -sf libmydll.so.0.0.0 libmydll.so.0 && ln -sf libmydll.so.0.0.0 libmydll.so" -*-
@end example
Ahora puedes compilarlo con @code{Compile} del men� @code{Tools}
y el c�digo resultante es cargado automaticamente cuando comienzas una nueva
sesi�n con @code{xcas} o @code{cas} que hace que comprobar sea m�s ligero.

@node Datos definidos por usuario, , Haciendo modulos, Giac
@cindex  Datos definidos por usuarios
@section  Datos definidos por usuario
La clase @code{gen_user} puede ser derivada de forma que puedes incluir
tus propios datos en @code{gen}. Mira la declaraci�n de @code{gen_user}
en el fichero @code{gen.h} y en el ejemplo de las quaternas
en los ficheros @code{quater.h} y @code{quater.cc}.

@node Ejemplos, Indice de conceptos, Giac, Top
@chapter Algunso ejemplos de programas en C++ usando giac

@menu
* Primer ejemplo::
@end menu

@node Primer ejemplo, , , Ejemplos
@chapter Un primer ejemplo
Teclea el texto siguiente con tu editor favorito

@smallexample
#include <giac/giac.h>
using namespace std;
using namespace giac;

int main()@{
  gen e(string("x^2-1"));
  cout << factor(e) << endl;
@}
@end smallexample

gu�rdalo como p.ej. @code{tryit.cc} y comp�lalo con

@command{c++ -g tryit.cc -lgiac -lgmp}

Si obitenes s�mbolos sin resolver, entonces puede que @code{readline} est� activada
y debas compilarlo como

@command{c++ -g tryit.cc -lgiac -lgmp -lreadline -lcurses}

Ahora puedes ejecutar @code{a.out} que imprimir� la factorizaci�n de
@code{x^2-1}.

Tambi�n puedes ejecutar el programa paso a paso usando gdb.
Recomendamos que copies el fichero @code{.gdbinit} del directorio @code{src}
de la distribuci�n giac, porque permite usar
@code{v nombrevar} para imprimir la variable @code{nombrevar} de tipo @code{gen}.

Algunas explicaciones del c�digo:
@itemize
@item la directiva @code{#include <giac/giac.h>}
incluye todas las cabeceras de giac (lo que incluye algunas cabeceras
de STL como @code{string} o @code{vector}).
@item la directiva @code{using namespace}
no es obligatoria, si no la usas, necesitas modificar
algo del c�digo, p.ej. usa @code{std::string} en vez de @code{string}
o @code{giac::gen} en lugar de @code{gen}.
@item Variables del tipo @code{gen}
pueden ser construidas a partir de cadenas (usando el int�rprete), a partir de algunos tipos de C
(como @code{int} o @code{double}), a partir de tipos de STL
@code{std::complex<double>} o a partir de secuencias (usando el int�rprete).
@item Operaciones como @code{+, -, *} est�n definidas en el tipo @code{gen}
pero la divisi�n no est� redefinida para evitar confusi�n entre enteros
(usa @code{iquo}) y divisi�n de double (reales) en C (usa @code{rdiv}). Para potencias,
usa @code{pow} como de constumbre.
@end itemize

@node Indice de conceptos,    ,  Ejemplos, Top
@comment node-name,    next,  previous, up
@unnumbered Concept Index

@printindex cp

@contents
@bye