Obteniendo Ayuda - Sage Tutorial

Skip to content
Back to top
View this page
Edit this page

# Obteniendo Ayuda

Sage posee una extensa documentación incorporada, accesible con solo teclear el nombre de una función o una constante (por ejemplo), seguido de un signo de interrogación:

Sage

    sage: tan?
    Type:        <class 'sage.calculus.calculus.Function_tan'>
    Definition:  tan( [noargspec] )
    Docstring:

        The tangent function

        EXAMPLES:
            sage: tan(pi)
            0
            sage: tan(3.1415)
            -0.0000926535900581913
            sage: tan(3.1415/4)
            0.999953674278156
            sage: tan(pi/4)
            1
            sage: tan(1/2)
            tan(1/2)
            sage: RR(tan(1/2))
            0.546302489843790
    sage: log2?
    Type:        <class 'sage.functions.constants.Log2'>
    Definition:  log2( [noargspec] )
    Docstring:

        The natural logarithm of the real number 2.

        EXAMPLES:
            sage: log2
            log2
            sage: float(log2)
            0.69314718055994529
            sage: RR(log2)
            0.693147180559945
            sage: R = RealField(200); R
            Real Field with 200 bits of precision
            sage: R(log2)
            0.69314718055994530941723212145817656807550013436025525412068
            sage: l = (1-log2)/(1+log2); l
            (1 - log(2))/(log(2) + 1)
            sage: R(l)
            0.18123221829928249948761381864650311423330609774776013488056
            sage: maxima(log2)
            log(2)
            sage: maxima(log2).float()
            .6931471805599453
            sage: gp(log2)
            0.693147180559945309417232121...
    sage: sudoku?
    File:        sage/local/lib/python2.5/site-packages/sage/games/sudoku.py
    Type:        <... 'function'>
    Definition:  sudoku(A)
    Docstring:

        Solve the 9x9 Sudoku puzzle defined by the matrix A.

        EXAMPLE:
            sage: A = matrix(ZZ,9,[5,0,0, 0,8,0, 0,4,9, 0,0,0, 5,0,0,
        0,3,0, 0,6,7, 3,0,0, 0,0,1, 1,5,0, 0,0,0, 0,0,0, 0,0,0, 2,0,8, 0,0,0,
        0,0,0, 0,0,0, 0,1,8, 7,0,0, 0,0,4, 1,5,0,   0,3,0, 0,0,2,
        0,0,0, 4,9,0, 0,5,0, 0,0,3])
            sage: A
            [5 0 0 0 8 0 0 4 9]
            [0 0 0 5 0 0 0 3 0]
            [0 6 7 3 0 0 0 0 1]
            [1 5 0 0 0 0 0 0 0]
            [0 0 0 2 0 8 0 0 0]
            [0 0 0 0 0 0 0 1 8]
            [7 0 0 0 0 4 1 5 0]
            [0 3 0 0 0 2 0 0 0]
            [4 9 0 0 5 0 0 0 3]
            sage: sudoku(A)
            [5 1 3 6 8 7 2 4 9]
            [8 4 9 5 2 1 6 3 7]
            [2 6 7 3 4 9 5 8 1]
            [1 5 8 4 6 3 9 7 2]
            [9 7 4 2 1 8 3 6 5]
            [3 2 6 7 9 5 4 1 8]
            [7 8 2 9 3 4 1 5 6]
            [6 3 5 1 7 2 8 9 4]
            [4 9 1 8 5 6 7 2 3]

Python

    >>> from sage.all import *
    >>> tan?
    Type:        <class 'sage.calculus.calculus.Function_tan'>
    Definition:  tan( [noargspec] )
    Docstring:

        The tangent function

        EXAMPLES:
    >>> tan(pi)
            0
    >>> tan(RealNumber('3.1415'))
            -0.0000926535900581913
    >>> tan(RealNumber('3.1415')/Integer(4))
            0.999953674278156
    >>> tan(pi/Integer(4))
            1
    >>> tan(Integer(1)/Integer(2))
            tan(1/2)
    >>> RR(tan(Integer(1)/Integer(2)))
            0.546302489843790
    >>> log2?
    Type:        <class 'sage.functions.constants.Log2'>
    Definition:  log2( [noargspec] )
    Docstring:

        The natural logarithm of the real number 2.

        EXAMPLES:
    >>> log2
            log2
    >>> float(log2)
            0.69314718055994529
    >>> RR(log2)
            0.693147180559945
    >>> R = RealField(Integer(200)); R
            Real Field with 200 bits of precision
    >>> R(log2)
            0.69314718055994530941723212145817656807550013436025525412068
    >>> l = (Integer(1)-log2)/(Integer(1)+log2); l
            (1 - log(2))/(log(2) + 1)
    >>> R(l)
            0.18123221829928249948761381864650311423330609774776013488056
    >>> maxima(log2)
            log(2)
    >>> maxima(log2).float()
            .6931471805599453
    >>> gp(log2)
            0.693147180559945309417232121...
    >>> sudoku?
    File:        sage/local/lib/python2.5/site-packages/sage/games/sudoku.py
    Type:        <... 'function'>
    Definition:  sudoku(A)
    Docstring:

        Solve the 9x9 Sudoku puzzle defined by the matrix A.

        EXAMPLE:
    >>> A = matrix(ZZ,Integer(9),[Integer(5),Integer(0),Integer(0), Integer(0),Integer(8),Integer(0), Integer(0),Integer(4),Integer(9), Integer(0),Integer(0),Integer(0), Integer(5),Integer(0),Integer(0),
        0,3,0, 0,6,7, 3,0,0, 0,0,1, 1,5,0, 0,0,0, 0,0,0, 0,0,0, 2,0,8, 0,0,0,
        0,0,0, 0,0,0, 0,1,8, 7,0,0, 0,0,4, 1,5,0,   0,3,0, 0,0,2,
        0,0,0, 4,9,0, 0,5,0, 0,0,3])
    >>> A
            [5 0 0 0 8 0 0 4 9]
            [0 0 0 5 0 0 0 3 0]
            [0 6 7 3 0 0 0 0 1]
            [1 5 0 0 0 0 0 0 0]
            [0 0 0 2 0 8 0 0 0]
            [0 0 0 0 0 0 0 1 8]
            [7 0 0 0 0 4 1 5 0]
            [0 3 0 0 0 2 0 0 0]
            [4 9 0 0 5 0 0 0 3]
    >>> sudoku(A)
            [5 1 3 6 8 7 2 4 9]
            [8 4 9 5 2 1 6 3 7]
            [2 6 7 3 4 9 5 8 1]
            [1 5 8 4 6 3 9 7 2]
            [9 7 4 2 1 8 3 6 5]
            [3 2 6 7 9 5 4 1 8]
            [7 8 2 9 3 4 1 5 6]
            [6 3 5 1 7 2 8 9 4]
            [4 9 1 8 5 6 7 2 3]

Sage también provee “Autocompletado con el tabulador”: teclea las primeras letras de una función y luego oprime la tecla del tabulador. Por ejemplo, si tecleas `ta` seguido por `TAB`, Sage imprimirá `tachyon, tan, tanh, taylor`. Esto proporciona una buena manera de encontrar los nombres de funciones y otras estructuras en Sage.

# Funciones, Indentación Y Conteo

Para definir una nueva función en Sage, utilice el comando `def` y el signo de dos puntos después de la lista de nombres de variable. Por ejemplo:

Sage

    sage: def is_even(n):
    ....:     return n % 2 == 0
    ....:
    sage: is_even(2)
    True
    sage: is_even(3)
    False

Python

    >>> from sage.all import *
    >>> def is_even(n):
    ...     return n % Integer(2) == Integer(0)
    ....:
    >>> is_even(Integer(2))
    True
    >>> is_even(Integer(3))
    False

Nota: Dependiendo de la versión del tutorial que estás leyendo, puede que veas puntos `....:` en la segunda línea de este ejemplo. No los incluyas; son solo para enfatizar que el código está indentado. Siempre que este sea el caso, presiona [Return/Enter] una vez al final del bloque para insertar una línea en blanco y concluir la definición de la función.

No tienes que especificar los tipos de ninguno de los argumentos de entrada. Puedes especificar múltiples entradas, cada una de las cuales puede tener un valor predeterminado opcional. Por ejemplo, la función de abajo tiene un valor predeterminado `divisor=2` si no se especifica el valor de `divisor`.

Sage

    sage: def is_divisible_by(number, divisor=2):
    ....:     return number % divisor == 0
    sage: is_divisible_by(6,2)
    True
    sage: is_divisible_by(6)
    True
    sage: is_divisible_by(6, 5)
    False

[Python]

    >>> from sage.all import *
    >>> def is_divisible_by(number, divisor=Integer(2)):
    ...     return number % divisor == Integer(0)
    >>> is_divisible_by(Integer(6),Integer(2))
    True
    >>> is_divisible_by(Integer(6))
    True
    >>> is_divisible_by(Integer(6), Integer(5))
    False

También puedes especificar explícitamente una o ambas de las entradas cuando llames a la función; si especificas las entradas explícitamente, puedes darlas en cualquier órden:

Sage

    sage: is_divisible_by(6, divisor=5)
    False
    sage: is_divisible_by(divisor=2, number=6)
    True

Python

    >>> from sage.all import *
    >>> is_divisible_by(Integer(6), divisor=Integer(5))
    False
    >>> is_divisible_by(divisor=Integer(2), number=Integer(6))
    True

En Python, los bloques de código no se encierran entre llaves o bloques begin…end como en muchos otros lenguajes. En vez de ello, los bloques de código se indican por medio de la indentación, la cual se debe agrupar con exactitud. Por ejemplo, el siguiente es un error de sintáxis porque la declaración `return` no está indentada al mismo nivel que las otras líneas por encima de ella.

Sage

    sage: def even(n):
    ....:     v = []
    ....:     for i in range(3,n):
    ....:         if i % 2 == 0:
    ....:             v.append(i)
    ....:    return v
    Syntax Error:
           return v

[Python]

    >>> from sage.all import *
    >>> def even(n):
    ...     v = []
    ...     for i in range(Integer(3),n):
    ...         if i % Integer(2) == Integer(0):
    ...             v.append(i)
    ...    return v
    Syntax Error:
           return v

Si arreglas la indentación, la función se ejecutará:

Sage

    sage: def even(n):
    ....:     v = []
    ....:     for i in range(3,n):
    ....:         if i % 2 == 0:
    ....:             v.append(i)
    ....:     return v
    sage: even(10)
    [4, 6, 8]

Python

    >>> from sage.all import *
    >>> def even(n):
    ...     v = []
    ...     for i in range(Integer(3),n):
    ...         if i % Integer(2) == Integer(0):
    ...             v.append(i)
    ...     return v
    >>> even(Integer(10))
    [4, 6, 8]

El punto y coma no es necesario al final de las líneas. Una línea termina, en muchos casos, por un carácter de nueva línea. Sin embargo, puedes poner múltiples declaraciones en una línea, separadas por punto y coma:

Sage

    sage: a = 5; b = a + 3; c = b^2; c
    64

[Python]

    >>> from sage.all import *
    >>> a = Integer(5); b = a + Integer(3); c = b**Integer(2); c
    64

Si quisieras que una simple línea de código abarque multiples líneas, utiliza una barra invertida como terminación:

Sage

    sage: 2 + \
    ....: 3
    5

Python

    >>> from sage.all import *
    >>> Integer(2) + Integer(3)
    5

En Sage, se cuenta iterando sobre un rango de enteros. Por ejemplo, la primer línea de abajo es exactamente igual a `for(i=0; i<3; i++)` en C++ o Java:

Sage

    sage: for i in range(3):
    ....:     print(i)
    0
    1
    2

[Python]

    >>> from sage.all import *
    >>> for i in range(Integer(3)):
    ...     print(i)
    0
    1
    2

La primer línea de abajo es igual a `for(i=2;i<5;i++)`.

Sage

    sage: for i in range(2,5):
    ....:     print(i)
    2
    3
    4

Python

    >>> from sage.all import *
    >>> for i in range(Integer(2),Integer(5)):
    ...     print(i)
    2
    3
    4

El tercer argumento controla el incremento, de modo que lo siguiente es igual a `for(i=1;i<6;i+=2)`.

Sage

    sage: for i in range(1,6,2):
    ....:     print(i)
    1
    3
    5

[Python]

    >>> from sage.all import *
    >>> for i in range(Integer(1),Integer(6),Integer(2)):
    ...     print(i)
    1
    3
    5

A menudo, querrás crear una tabla para presentar números que has calculado utilizando Sage. Una manera sencilla de hacer esto es usando el formateado de cadenas. Abajo, creamos tres columnas, cada una con un ancho exácto de 6 caracteres y hacemos una tabla de cuadrados y cubos.

Sage

    sage: for i in range(5):
    ....:     print('%6s %6s %6s' % (i, i^2, i^3))
         0      0      0
         1      1      1
         2      4      8
         3      9     27
         4     16     64

Python

    >>> from sage.all import *
    >>> for i in range(Integer(5)):
    ...     print('%6s %6s %6s' % (i, i**Integer(2), i**Integer(3)))
         0      0      0
         1      1      1
         2      4      8
         3      9     27
         4     16     64

La estructura de datos más básica en Sage es la lista, la cual es – como sugiere su nombre – solo una lista de objetos arbitrarios. Por ejemplo, el comando `range` que hemos usado crea una lista:

Sage

    sage: list(range(2,10))
    [2, 3, 4, 5, 6, 7, 8, 9]

[Python]

    >>> from sage.all import *
    >>> list(range(Integer(2),Integer(10)))
    [2, 3, 4, 5, 6, 7, 8, 9]

He aquí una lista más complicada:

Sage

    sage: v = [1, "hello", 2/3, sin(x^3)]
    sage: v
    [1, 'hello', 2/3, sin(x^3)]

Python

    >>> from sage.all import *
    >>> v = [Integer(1), "hello", Integer(2)/Integer(3), sin(x**Integer(3))]
    >>> v
    [1, 'hello', 2/3, sin(x^3)]

El indexado de una lista comienza en el cero, como en muchos lenguajes de programación.

Sage

    sage: v[0]
    1
    sage: v[3]
    sin(x^3)

[Python]

    >>> from sage.all import *
    >>> v[Integer(0)]
    1
    >>> v[Integer(3)]
    sin(x^3)

La función `len(v)` devuelve la longitud de `v`. Utiliza `v.append(obj)` para añadir un nuevo objeto al final de `v`, y utiliza `del v[i]` para borrar el \(i\)-ésimo elemento de `v`:

Sage

    sage: len(v)
    4
    sage: v.append(1.5)
    sage: v
    [1, 'hello', 2/3, sin(x^3), 1.50000000000000]
    sage: del v[1]
    sage: v
    [1, 2/3, sin(x^3), 1.50000000000000]

Python

    >>> from sage.all import *
    >>> len(v)
    4
    >>> v.append(RealNumber('1.5'))
    >>> v
    [1, 'hello', 2/3, sin(x^3), 1.50000000000000]
    >>> del v[Integer(1)]
    >>> v
    [1, 2/3, sin(x^3), 1.50000000000000]

Otra estructura de datos importante es el diccionario (o array asociativo). Funciona como una lista, excepto que puede ser indexado con casi cualquier objeto (los índices deben ser immutables):

Sage

    sage: d = {'hi':-2,  3/8:pi,   e:pi}
    sage: d['hi']
    -2
    sage: d[e]
    pi

[Python]

    >>> from sage.all import *
    >>> d = {'hi':-Integer(2),  Integer(3)/Integer(8):pi,   e:pi}
    >>> d['hi']
    -2
    >>> d[e]
    pi

También puedes definir nuevos tipos de datos usando clases. El encapsulado de objetos matemáticos con clases es una técnica potente que puede ayudar a simplificar y organizar tus programas en Sage. Abajo, definimos una clase que representa la lista de enteros positivos pares hasta `n`; se deriva de el tipo básico `list`.

Sage

    sage: class Evens(list):
    ....:     def __init__(self, n):
    ....:         self.n = n
    ....:         list.__init__(self, range(2, n+1, 2))
    ....:     def __repr__(self):
    ....:         return "Even positive numbers up to n."

Python

    >>> from sage.all import *
    >>> class Evens(list):
    ...     def __init__(self, n):
    ...         self.n = n
    ...         list.__init__(self, range(Integer(2), n+Integer(1), Integer(2)))
    ...     def __repr__(self):
    ...         return "Even positive numbers up to n."

El método `__init__` se llama para inicializar al objeto cuando es creado; el método `__repr__` imprime el objeto. Llamamos al método constructor de listas en la segunda línea del método `__init__`. A continuación, creamos un objeto de clase `Evens`:

Sage

    sage: e = Evens(10)
    sage: e
    Even positive numbers up to n.

[Python]

    >>> from sage.all import *
    >>> e = Evens(Integer(10))
    >>> e
    Even positive numbers up to n.

Observe que `e` se imprime usando el método `__repr__` que hemos definido. Para ver la lista subyacente de números, utilice la función `list`:

Sage

    sage: list(e)
    [2, 4, 6, 8, 10]

Python

    >>> from sage.all import *
    >>> list(e)
    [2, 4, 6, 8, 10]

También podemos acceder al atributo `n` o tratar a `e` como una lista.

Sage

    sage: e.n
    10
    sage: e[2]
    6

[Python]

    >>> from sage.all import *
    >>> e.n
    10
    >>> e[Integer(2)]
    6