2429-Search Documentation: \"rgbcolor\".sagews

Breve y elemental introducción a Sage

Manejo básico de Sage:

• Para ejecutar el contenido de una celda has de presionar shift-enter.
• El símbolo "#" indica el inicio de un comentario.
• El símbolo "_" representa el último resultado obtenido.
• Cuidado con la sangría en las líneas.

1. Sage es una calculadora

Puedes usar Sage como una calculadora. El orden de los paréntesis es el usual:

1 + 1

2

2 * (2 +3)

10

Sage manipula números racionales. Los símbolos "^" y "**" corresponden a "elevado a".

(2 + 1)^10 / 8

59049/8

Sage permite el acceso al último resultado obtenido. Por ejemplo, el tipo del último resultado es racional:

type(_)

<type 'sage.rings.rational.Rational'>

Sage es de hecho una calculadora muy pero que muy potente:

2^100

1267650600228229401496703205376

Sage tiene algunas constantes predeterminadas como $\pi$, e, ...

Los resultados se pueden calcular con gran precisión mediante la función N. Por ejemplo, $\pi$ calculado con 1000 dígitos (la opción time indica al final el tiempo usado):

time N(pi, digits = 1000)

3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930381964428810975665933446128475648233786783165271201909145648566923460348610454326648213393607260249141273724587006606315588174881520920962829254091715364367892590360011330530548820466521384146951941511609433057270365759591953092186117381932611793105118548074462379962749567351885752724891227938183011949129833673362440656643086021394946395224737190702179860943702770539217176293176752384674818467669405132000568127145263560827785771342757789609173637178721468440901224953430146549585371050792279689258923542019956112129021960864034418159813629774771309960518707211349999998372978049951059731732816096318595024459455346908302642522308253344685035261931188171010003137838752886587533208381420617177669147303598253490428755468731159562863882353787593751957781857780532171226806613001927876611195909216420199 Time: CPU 0.00 s, Wall: 0.00 s

Sage posee multitud de funciones elementales usuales: exp(x), log(x), log(x,base), sin(x), cos(x), tan(x), arcsin(x), arccos(x), arctan(x), ...

Sage puede realizar cálculos aritméticos rápidamente:

# Factorizar:
factor(2010)

2 * 3 * 5 * 67

# Máximo común divisor:
gcd(2010,13)

1

# Mínimo común múltiplo
lcm(4,2010)

4020

Sage puede hacer cálculos con matrices:

Crear matrices:

A = matrix([[5,-1,1],[-3,3,-1],[-2,-2,4]])

Operar con matrices para obtener otras nuevas: por ejemplo, B es A menos la traspuesta de A:

B = A - transpose(A)

Producto de A por B:

A*B

[-1 9 14] [-3 -5 -6] [-8 -8 -8]

Determinante:

det(A)

48

Inversa:

A.inverse()

[ 5/24 1/24 -1/24] [ 7/24 11/24 1/24] [ 1/4 1/4 1/4]

Dada una matriz A, podemos resolver sistemas de ecuaciones con matriz de coeficientes A, creando el vector de términos independientes y usando el comando "\":

b = vector([1, 2, 3]);                         
A\b

(1/6, 4/3, 3/2)

También podemos obtener el polinomio característico de una matriz:

A.characteristic_polynomial()

x^3 - 12*x^2 + 44*x - 48

Y encontrar sus raíces mediante solve (sólo vale para algunos polinomios):

solve(x^3 - 12*x^2 + 44*x - 48 == 0, x)

[x == 4, x == 2, x == 6]

Estas raíces son en realidad los valores propios de A:

A.eigenvalues()

[6, 4, 2]

Podemos también escalonar una matriz por filas (hacer eliminacion gaussiana):

A.echelon_form()

[ 1 7 3] [ 0 12 2] [ 0 0 4]

Calcula una base del núcleo de una matriz (el conjunto de vectores que multiplicados a izquierda por esa matriz dan cero):

B.kernel()

Free module of degree 3 and rank 1 over Integer Ring Echelon basis matrix: [ 1 -3 2]

Y mucho, mucho más...

Sage es una calculadora gráfica

Sage puede representar gráficamente funciones en intervalos determinados:

plot(x^3 + 2*x^2 - 3*x - 1, (x,-3,3))

Los gráficos se pueden superponer mediante +, y se les puede asignar color mediante rgbcolor. También podemos incluir texto indicando las coordenadas en que queremos que aparezca:

plot(sin(x),(x,-5,5)) + text('sin(x)',(0.6,-0.1)) + plot(cos(x),(x,-5,5),rgbcolor = (1,0,0)) + text('cos(x)',(0.6,1.1),rgbcolor = (1,0,0))

Los gráficos también pueden ser tridimensionales (nota: elegimos el visualizador de imágenes porque el estándar (Jmol) de momento da problemas al cargar en el navegador):

var('x y z')
dibujo= plot3d(sin(100*x)*exp(y),(x,-1,1),(y,-1,1))
dibujo.show(viewer='canvas3d')

Sage representa figuras definidas por ecuaciones paramétricas (se pueden mover con el ratón):

var('u,v');
fx = (3 + sin(v) + cos(u))*cos(2*v)
fy = (3 + sin(v) + cos(u))*sin(2*v)
fz = sin(u) + 2*cos(v)
dibujo=parametric_plot3d([fx, fy, fz], (u, 0, 2*pi), (v, 0, 2*pi), frame=False, color="red")
dibujo.show(viewer='canvas3d')

Sage representa gráficas de ecuaciones implícitas complicadas (nota: no podemos acceder a la versión dinámica, así que elegimos un visualizador estático):

dibujo= implicit_plot3d(1/sin(x*y*z*15)==1/2,(x,-1,1),(y,-1,1),(z,-2,2))
dibujo.show(viewer='tachyon')

3. Sage es un sistema de cálculo simbólico

Sage realiza cálculos simbólicos. Para ello, primero se declaran las variables que se van a usar para que las reconozca como tales:

var('a b')  
s = expand((a+b)^3)    # Cubo de una suma
s

a^3 + 3*a^2*b + 3*a*b^2 + b^3

Observar que escribe 3*a^2*b, usando el asterisco para indicar productos. Es importante que tú hagas lo mismo y no te los olvides (en otro caso, interpretará la expresión completa como una nueva variable).

Sage factoriza polinomios en varias variables:

factor(s)

(a + b)^3

Sage permite presentar las expresiones con un formato más legible pero no hay que confundir la presentación con la expresión, son cosas totalmente diferentes.

show(s)

\newcommand{\Bold}[1]{\mathbf{#1}}a^{3} + 3 \, a^{2} b + 3 \, a b^{2} + b^{3}

Para liberar declaraciones de variables se usa reset:

reset()         # Libera todas las declaraciones

Sage realiza operaciones usuales de cálculo (análisis matemático):

Define funciones:

var('x')
f(x) = log(x)

Con diff se calcula la derivada (al igual que derivative):

diff(f(x))

1/x

También podemos calcular primitivas:

integral(f(x),x)

x*log(x) - x

Calcula límites (oo denota infinito):

limit(sin(x)/x, x=0)

1

limit(sqrt(3*x^2 + x + 1)/x, x = oo)

sqrt(3)

Y mucho, pero que mucho mucho más...

4. Ayuda en Sage

Para obtener información acerca de algún comando basta teclear ? después de él y ejecutar:

exp?

File: /usr/local/sage2/local/lib/python2.6/site-packages/sage/functions/log.py

Type: <class ‘sage.functions.log.Function_exp’>

Definition: exp(x, coerce=True, hold=False, prec=None, dont_call_method_on_arg=False)

Docstring:

The exponential function, \exp(x) = e^x.

EXAMPLES:

sage: exp(-1)
e^(-1)
sage: exp(2)
e^2
sage: exp(2).n(100)
7.3890560989306502272304274606
sage: exp(x^2 + log(x))
e^(x^2 + log(x))
sage: exp(x^2 + log(x)).simplify()
x*e^(x^2)
sage: exp(2.5)
12.1824939607035
sage: exp(float(2.5))
12.182493960703473
sage: exp(RDF('2.5'))
12.1824939607

sage: exp(pi*I/2)
I
sage: exp(pi*I)
-1
sage: exp(8*pi*I)
1
sage: exp(7*pi*I/2)
-I

TEST:

sage: latex(exp(x))
e^{x}
sage: latex(exp(sqrt(x)))
e^{\sqrt{x}}
sage: latex(exp)
\exp
sage: latex(exp(sqrt(x))^x)
\left(e^{\sqrt{x}}\right)^{x}
sage: latex(exp(sqrt(x)^x))
e^{\left(\sqrt{x}^{x}\right)}

Test simplifications when taking powers of exp, #7264:

sage: var('a,b,c,I')
(a, b, c, I)
sage: model_exp = exp(I)**a*(b)
sage: sol1_l={b: 5.0, a: 1.1}
sage: model_exp.subs(sol1_l)
5.00000000000000*(e^I)^1.10000000000000

sage: exp(3)^I*exp(x)
(e^3)^I*e^x
sage: exp(x)*exp(x)
e^(2*x)
sage: exp(x)*exp(a)
e^(a + x)
sage: exp(x)*exp(a)^2
e^(2*a + x)

Another instance of the same problem, #7394:

sage: 2*sqrt(e)
2*sqrt(e)

Una información más técnica se tiene con ?? (orientada a programadores o desarrolladores):

exp??

File: /usr/local/sage2/local/lib/python2.6/site-packages/sage/functions/log.py

Source Code (starting at line 10):

class Function_exp(GinacFunction):
    def __init__(self):
        r"""
        The exponential function, `\exp(x) = e^x`.

        EXAMPLES::

            sage: exp(-1)
            e^(-1)
            sage: exp(2)
            e^2
            sage: exp(2).n(100)
            7.3890560989306502272304274606
            sage: exp(x^2 + log(x))
            e^(x^2 + log(x))
            sage: exp(x^2 + log(x)).simplify()
            x*e^(x^2)
            sage: exp(2.5)
            12.1824939607035
            sage: exp(float(2.5))
            12.182493960703473
            sage: exp(RDF('2.5'))
            12.1824939607

        ::

            sage: exp(pi*I/2)
            I
            sage: exp(pi*I)
            -1
            sage: exp(8*pi*I)
            1
            sage: exp(7*pi*I/2)
            -I

        TEST::

            sage: latex(exp(x))
            e^{x}
            sage: latex(exp(sqrt(x)))
            e^{\sqrt{x}}
            sage: latex(exp)
            \exp
            sage: latex(exp(sqrt(x))^x)
            \left(e^{\sqrt{x}}\right)^{x}
            sage: latex(exp(sqrt(x)^x))
            e^{\left(\sqrt{x}^{x}\right)}

        Test simplifications when taking powers of exp, #7264::

            sage: var('a,b,c,I')
            (a, b, c, I)
            sage: model_exp = exp(I)**a*(b)
            sage: sol1_l={b: 5.0, a: 1.1}
            sage: model_exp.subs(sol1_l)
            5.00000000000000*(e^I)^1.10000000000000

        ::

            sage: exp(3)^I*exp(x)
            (e^3)^I*e^x
            sage: exp(x)*exp(x)
            e^(2*x)
            sage: exp(x)*exp(a)
            e^(a + x)
            sage: exp(x)*exp(a)^2
            e^(2*a + x)

        Another instance of the same problem, #7394::

            sage: 2*sqrt(e)
            2*sqrt(e)
        """
        GinacFunction.__init__(self, "exp", latex_name=r"\exp",
                                   conversions=dict(maxima='exp'))

    def __call__(self, x, coerce=True, hold=False, prec=None,
            dont_call_method_on_arg=False):
        """
        Note that the ``prec`` argument is deprecated. The precision for
        the result is deduced from the precision of the input. Convert
        the input to a higher precision explicitly if a result with higher
        precision is desired.::

            sage: t = exp(RealField(100)(2)); t
            7.3890560989306502272304274606
            sage: t.prec()
            100

        TESTS::

            sage: exp(2,prec=100)
            doctest:...: DeprecationWarning: The prec keyword argument is deprecated. Explicitly set the precision of the input, for example exp(RealField(300)(1)), or use the prec argument to .n() for exact inputs, e.g., exp(1).n(300), instead.
            7.3890560989306502272304274606
        """
        if prec is not None:
            from sage.misc.misc import deprecation
            deprecation("The prec keyword argument is deprecated. Explicitly set the precision of the input, for example exp(RealField(300)(1)), or use the prec argument to .n() for exact inputs, e.g., exp(1).n(300), instead.")
            x = GinacFunction.__call__(self, x, coerce=coerce, hold=hold,
                    dont_call_method_on_arg=dont_call_method_on_arg)
            return x.n(prec)
        return GinacFunction.__call__(self, x, coerce=coerce, hold=hold,
                dont_call_method_on_arg=dont_call_method_on_arg)

Sage permite buscar información en la documentación proporcionando los enlaces correspondientes:

search_doc("rgbcolor")

Warning, the following Sage documentation hasn't been built, so documentation search results may be incomplete: /usr/local/sage2/devel/sage/doc/output/html/en/thematic_tutorials /usr/local/sage2/devel/sage/doc/output/html/en/faq You can build these with 'sage -docbuild DOCUMENT html', where DOCUMENT is one of 'thematic_tutorials', 'faq', or you can use 'sage -docbuild all html' to build all of the missing documentation.

Search Documentation: "rgbcolor"

1. bordeaux_2008/elliptic_curves.html
2. constructions/calculus.html
3. constructions/plotting.html
4. reference/sage/calculus/calculus.html
5. reference/sage/combinat/iet/iet.html
6. reference/sage/combinat/words/paths.html
7. reference/sage/functions/piecewise.html
8. reference/sage/groups/perm_gps/cubegroup.html
9. reference/sage/plot/animate.html
10. reference/sage/plot/arrow.html
11. reference/sage/plot/bar_chart.html
12. reference/sage/plot/bezier_path.html
13. reference/sage/plot/circle.html
14. reference/sage/plot/disk.html
15. reference/sage/plot/line.html
16. reference/sage/plot/plot.html
17. reference/sage/plot/plot3d/platonic.html
18. reference/sage/plot/plot3d/shapes2.html
19. reference/sage/plot/point.html
20. reference/sage/plot/polygon.html
21. reference/sage/plot/primitive.html
22. reference/sage/plot/step.html
23. reference/sage/plot/text.html
24. reference/sage/rings/arith.html
25. reference/sage/rings/padics/padic_base_generic.html
26. reference/sage/rings/polynomial/groebner_fan.html
27. reference/sage/rings/polynomial/polynomial_element.html
28. reference/sage/schemes/elliptic_curves/ell_finite_field.html
29. reference/sage/schemes/elliptic_curves/ell_generic.html
30. reference/sage/schemes/elliptic_curves/ell_point.html
31. reference/sage/schemes/elliptic_curves/heegner.html
32. reference/sage/symbolic/expression.html
33. reference/sagenb/notebook/interact.html
34. tutorial/tour_algebra.html
35. tutorial/tour_plotting.html
36. tutorial/tour_algebra.html
37. tutorial/tour_plotting.html

Si se teclea parte de un comando y se pulsa tab Sage intentará completarlo o mostrará un menú para elegir entre todos los comandos que comiencen por esas letras:

exp

exp