Ticket #12847: trac_12847_catalan_tutorial.patch

File trac_12847_catalan_tutorial.patch, 30.0 KB (added by Marc Masdeu, 10 years ago)

Only need to apply this patch

  • new file doc/ca/tutorial/conf.py

    # HG changeset patch
    # User Marc Masdeu <masdeu@math.columbia.edu>
    # Date 1360247112 18000
    # Node ID 6e99dcaf8aa69ba0217de27cad749bd99dc92ece
    # Parent  02cb1d5d89e28ab6b2c23e6c60187014a43b5b29
    Trac #12847: Catalan introduction to Sage.
    Added catalan tutorial.
    
    diff --git a/doc/ca/tutorial/conf.py b/doc/ca/tutorial/conf.py
    new file mode 100644
    - +  
     1# -*- coding: utf-8 -*-
     2#
     3# Sage documentation build configuration file, created by
     4# sphinx-quickstart on Thu Aug 21 20:15:55 2008.
     5#
     6# This file is execfile()d with the current directory set to its containing dir.
     7#
     8# The contents of this file are pickled, so don't put values in the namespace
     9# that aren't pickleable (module imports are okay, they're removed automatically).
     10#
     11# All configuration values have a default; values that are commented out
     12# serve to show the default.
     13
     14import sys, os
     15sys.path.append(os.environ['SAGE_DOC'])
     16from common.conf import *
     17
     18# General information about the project.
     19project = u"Tutorial de Sage"
     20
     21# The name for this set of Sphinx documents.  If None, it defaults to
     22# "<project> v<release> documentation".
     23html_title = project + " v"+release
     24
     25# Output file base name for HTML help builder.
     26htmlhelp_basename = 'TutorialdeSage'
     27
     28# Grouping the document tree into LaTeX files. List of tuples
     29# (source start file, target name, title, author, document class [howto/manual]).
     30latex_documents = [
     31  ('index', 'TutorialdeSage.tex', u'Tutorial de Sage',
     32   u'The Sage Development Team', 'manual'),
     33]
     34
  • new file doc/ca/tutorial/index.rst

    diff --git a/doc/ca/tutorial/index.rst b/doc/ca/tutorial/index.rst
    new file mode 100644
    - +  
     1.. Sage documentation master file, created by sphinx-quickstart on Thu Aug 21 20:15:55 2008.
     2   You can adapt this file completely to your liking, but it should at least
     3   contain the root `toctree` directive.
     4
     5==============================
     6Benvinguts al tutorial de Sage
     7==============================
     8
     9Sage és un programari matemàtic gratuït i de codi obert que dóna suport a la recerca i l'ensenyament en àlgebra, geometria, teoria de nombres, criptografia,
     10càlcul numèric, i àrees relacionades. Tant el model de desenvolupament de Sage com la tecnologia pròpia de Sage es distingeixen per un èmfasi extremadament fort en el fet de ser lliure, en la comunitat, la cooperació i la col·laboració: estem construint el cotxe, no pas reinventant  la roda. L'objectiu global de Sage és el de crear una alternativa viable, lliure, i de codi obert als paquets de Maple, Mathematica, Magma, i MATLAB.
     11
     12Aquest tutorial és una introducció al Sage basada en un manual escrit per Maria Bras-Amorós. Es pot llegir bé sigui en HTML o en PDF.
     13
     14Aquest tutorial està publicat amb una llicència `Creative Commons Attribution-Share Alike 3.0 License`__.
     15
     16__ http://creativecommons.org/licenses/by-sa/3.0/
     17
     18.. toctree::
     19   :maxdepth: 2
     20
     21Indicacions per començar
     22========================
     23
     24- La pàgina oficial de Sage és http://sagemath.org. Des d'allà podeu descarregar-vos el programa.
     25- Es comença amb ``sage`` i s'acaba amb ``quit``.
     26- Totes les ordres han d'acabar en salt de línia.
     27- Per interrompre un càlcul: ``Ctrl + C``.
     28- Es pot fer servir la tecla :math:`\uparrow` per recuperar codi escrit anteriorment.
     29- Per escriure ordres de sistema: ``!ordre``.
     30- Per llegir el fitxer ``fin.sage``: ``load  fin.sage``.
     31- Per llegir el fitxer ``fin.sage`` i escriure els resultats al fitxer ``fout``:  ``sage fin.sage > fout``.
     32- Per comentar una línia utilitzem ``# ...``. Tot el que hi hagi després de ``#`` no serà llegit per Sage.
     33- Per comentar tot un paràgraf o part d'un fitxer escrivim tres vegades cometes al principi i al final i el que quedi entremig no serà llegit per Sage::
     34
     35    """
     36    bla
     37    bla
     38    bla
     39    """
     40
     41- Per buscar ordres, escrivim les primeres lletres i utilizem el tabulador per veure les possibles complecions.
     42
     43Accions simples i expressions
     44=============================
     45
     46Assignació de variables i escriptura
     47------------------------------------
     48
     49- Per assignar variables: ``nom_variable = valor``.
     50- Per mostrar per pantalla:
     51
     52  + El valor de les variables ``var1, var2``: ``print var1, var2``.
     53  + Text: ``print "Un text"``.
     54
     55Operadors relacionals
     56---------------------
     57
     58- ``<`` (menor que), ``>`` (major que), ``<=`` (menor o igual que), ``>=`` (major o igual que),
     59- ``==`` (igual que), ``!=`` (diferent de),
     60- ``in`` (pertany), ``not in`` (no pertany).
     61
     62Operadors booleans
     63------------------
     64
     65- ``x and y`` (`x` i `y`),
     66- ``x or y`` (`x` o `y`),
     67- ``not x`` (no `x`).
     68
     69Funcions definides pel Sage
     70---------------------------
     71
     72Sage té definides les seves pròpies
     73funcions que depenen d'una o vàries variables (o cap).
     74Per cridar-les escrivim el nom de la funció
     75seguit de les variables entre parèntesis.
     76Per exemple::
     77
     78    sage: floor(3.141592)
     79    3
     80    sage: gcd(12,8)
     81    4
     82    sage: sum([3,2,5])
     83    10
     84
     85Hi ha funcions que retornen més d'un valor. Per exemple la funció
     86``divmod(a,b)`` ens retorna el quocient i el residu de dividir
     87`a` entre `b`::
     88
     89    sage: divmod(19,7)
     90    (2, 5)
     91
     92Per assignar aquests valors a variables ho fem de la manera següent::
     93
     94    sage: q,r = divmod(19,7)
     95    sage: q
     96    2
     97    sage: r
     98    5
     99
     100També podríem assignar el parell de valors a una sola variable::
     101
     102    sage: D = divmod(19,7)
     103    sage: D
     104    (2, 5)
     105    sage: D[0]
     106    2
     107    sage: D[1]
     108    5
     109
     110Composició d'accions
     111====================
     112
     113Composició condicional
     114----------------------
     115
     116L'estructura següent executarà ``bloc1`` només si ``condicio1`` és certa. El bloc ``bloc2`` només
     117s'executarà si ``condicio1`` és falsa, i ``condicio2`` és certa. Si ambdues condicions són falses,
     118aleshores s'executarà ``bloc3``.
     119
     120Cal tenir en compte que la indentació determina l'inici i fi dels blocs i que, per tant, és obligatòria.
     121
     122.. skip
     123
     124 ::
     125
     126    sage: if condicio1:
     127    ...       bloc1
     128    ...   elif condicio2:
     129    ...       bloc2
     130    ...   else:
     131    ...       bloc3
     132
     133Composició iterativa
     134--------------------
     135
     136Les estructures següents executaran ``bloc`` repetides vegades. La primera ho farà `i_0 - i_1 + 1` vegades,
     137i la variable ``i`` prendrà valors consecutius :math:`i_0,\ldots,i_1`. El segon bloc és similar, però ``i`` prendrà els valors que apareguin a ``llista``, en el mateix ordre en què hi apareguin. Finalment, el tercer bloc s'executarà mentre ``condicio`` sigui certa. Si ``condicio`` és falsa al començament, ``bloc`` no s'executarà cap vegada.
     138
     139.. skip
     140
     141::
     142
     143    sage: for i in [i0..i1]:
     144    ...       bloc
     145
     146    sage: for i in llista:
     147    ...       bloc
     148
     149    sage: while condicio:
     150    ...       bloc
     151
     152Exemples:
     153
     154::
     155
     156    sage: for i in [2..5]:
     157    ...       print i + 1
     158    3
     159    4
     160    5
     161    6
     162
     163::
     164
     165    sage: for i in [-1,"foo",3.4]:
     166    ...       print i
     167    -1
     168    foo
     169    3.40000000000000
     170
     171::
     172
     173    sage: i = 1
     174    sage: while i < 4:
     175    ...       print i
     176    ...       i += 1
     177    1
     178    2
     179    3
     180
     181Conjunts i seqüències
     182=====================
     183
     184Conjunts i seqüències
     185---------------------
     186
     187Tant els conjunts (``set``) com les seqüències (``list``)
     188són col·leccions d'objectes.
     189Un conjunt no és ordenat, per tant, un element pot ser en un
     190conjunt com a molt una vegada.
     191Una seqüència, en canvi,
     192és ordenada i, per tant, la
     193repetició és possible.
     194Les seqüències s'escriuen entre ``[`` i ``]``.
     195Els conjunts es construeixen a partir de seqüències fent servir ``Set(sequencia)``.
     196
     197
     198Per exemple::
     199
     200    sage: S = [ (-11)^2, (-7)^2, (-5)^2, (-3)^2, 3^2, 5^2, 7^2, 11^2 ]
     201    sage: C = Set(S)
     202    sage: S
     203    [121, 49, 25, 9, 9, 25, 49, 121]
     204    sage: C
     205    {121, 9, 49, 25}
     206
     207La `i`-èssima entrada d'una seqüència (o d'un conjunt) `C`
     208és ``C[i]``. Però compte perquè Sage
     209enumera les posicions des de `0`!:
     210
     211.. link
     212
     213::
     214    sage: S[1] = 1000
     215    sage: S
     216    [121, 1000, 25, 9, 9, 25, 49, 121]
     217    sage: S[3]
     218    9
     219
     220Sage té constructors especials per a seqüències.
     221Les expressions ``[a..b]`` i ``[a,a+k..b]`` designen respectivament
     222les progressions ``[a,a+1,a+2,...,b]`` i ``[a,a+k,a+2k,...,b']``,
     223on `b'` és el màxim enter de la forma `a+ik` menor o igual que `b`.
     224
     225D'altra banda,
     226
     227.. skip
     228
     229::
     230
     231    [ expressio(x) for x in D ]
     232    [ expressio(x,y) for x in D for y in E ]
     233
     234denota
     235la seqüència de valors
     236``expressio(x)`` (resp. ``expressió(x,y)``)
     237avaluada per tot :math:`x\in D` (resp. :math:`x\in D, y\in E`).
     238
     239Així mateix,
     240
     241.. skip
     242
     243::
     244
     245    [ expressio(x) for x in D if condicio ]
     246
     247denota
     248la seqüència de valors ``expressio(x)`` avaluada per tot :math:`x\in D`
     249tals que el booleà ``condicio`` és cert.
     250Per exemple, hauríem pogut crear ``S``
     251de la manera següent::
     252
     253    sage: S = [ n^2 for n in [-11,-9..11] if is_prime(abs(n)) ]
     254    sage: print S
     255    [121, 49, 25, 9, 9, 25, 49, 121]
     256
     257Podem aplicar una funció a tots els elements d'una llista de la manera següent::
     258
     259    sage: map(cos, [0,pi..6*pi])
     260    [1, -1, 1, -1, 1, -1, 1]
     261
     262
     263Operacions per conjunts i seqüències
     264------------------------------------
     265
     266- ``len(S)`` retorna el cardinal de `S`.
     267- ``sum(S)`` retorna la suma dels elements de `S`.
     268- ``prod(S)`` retorna el producte dels elements de `S`.
     269- ``S + T``  retorna `S` concatenat amb `T`.
     270- ``min(S)``, ``max(S)`` retorna el mínim i el màxim de ``S``, que ha de contenir elements amb un ordre.
     271
     272
     273Operacions només per conjunts
     274-----------------------------
     275
     276- ``A.union(B)`` retorna :math:`A\cup B`.
     277- ``A.intersection(B)`` retorna :math:`A\cap B`.
     278- ``A.difference(B)`` retorna :math:`A\setminus B`.
     279
     280Operacions només per seqüències
     281-------------------------------
     282
     283- ``S.append(x)`` afegeig `x` al final de `S`.
     284- ``S.remove(x)`` esborra `x` de `S`.
     285- ``S.index(x)`` retorna la posició de l'element `x` dins de `S`.
     286- ``S.insert(i,x)`` mou una posició els elements amb índex igual o superior a `i` i afegeix `x` a la posició `i`.
     287- ``S.reverse()`` capgira la seqüència `S`.
     288- ``S.sort()`` ordena la seqüència `S`.
     289- ``S[randint(0,len(S))]`` retorna un element aleatori de `S`.
     290
     291Booleans
     292........
     293
     294- ``x in C``, ``x not in C`` determina si `x` pertany o no a `C`.
     295- ``A.issubset(B)``, ``A.issuperset(B)`` determina si `A` és un subconjunt de `B`, o si `A` conté a `B` com a subconjunt (només per conjunts).
     296- ``D == C``, ``D != C`` determina si `D` és igual a `C` o no.
     297
     298Funcions
     299========
     300
     301
     302La declaració general d'una funció
     303de `n` arguments
     304per la que s'hagi de fer
     305una sèrie d'operacions és::
     306
     307.. skip
     308
     309    def f(x1, x2, ..., xn):
     310        ...
     311        return (val1, val2, ...)
     312
     313Per exemple::
     314
     315    sage: def solucions_reals_equacio_segon_grau(a,b,c):
     316    ...       discriminant = b^2 - 4*a*c
     317    ...       arrel_discr = sqrt(discriminant)
     318    ...       if discriminant > 0:
     319    ...           print "hi ha dues solucions reals"
     320    ...           sol1 = (-b + arrel_discr) / (2*a)
     321    ...           sol2 = (-b - arrel_discr) / (2*a)
     322    ...           return (sol1, sol2)
     323    ...       elif discriminant == 0:
     324    ...           print "hi ha una solucio real"
     325    ...           sol = -b / (2*a)
     326    ...           return (sol)
     327    ...       else:
     328    ...           print "no hi ha solucions reals"
     329    ...           return ()
     330
     331Observem que l'indentat és important.
     332Ara podem cridar-la:
     333
     334.. link
     335
     336::
     337    sage: solucions_reals_equacio_segon_grau(1,0,-1)
     338    hi ha dues solucions reals
     339    (1, -1)
     340
     341Com que en l'exemple donat la funció retorna dos valors, podem assignar-los a dues variables:
     342
     343.. link
     344
     345::
     346    sage: a,b = solucions_reals_equacio_segon_grau(1,0,-1)
     347    hi ha dues solucions reals
     348    sage: a
     349    1
     350    sage: b
     351    -1
     352
     353Aquesta crida, però, ens donaria un error si la solució no existís o fos única.
     354
     355Observem que totes les variables utilitzades
     356són per defecte locals i que
     357no ha calgut declarar-les. Una variable externa a la funció amb nom igual a una de
     358les variables locals
     359no es modificarà a causa de la funció. Per exemple, considerem la funció `f`:
     360
     361::
     362
     363    sage: def f():
     364    ...       a = 5
     365    ...       return a
     366
     367Observem el resultat del codi següent:
     368
     369.. link
     370
     371::
     372    sage: a = 3
     373    sage: print f()
     374    5
     375    sage: print a
     376    3
     377
     378
     379Enters, anells :math:`\mathbb{Z}/n\mathbb{Z}`, racionals i reals
     380================================================================
     381
     382Enters
     383------
     384
     385L'anell dels enters el cridem o bé amb ``Integers()``
     386o bé amb ``ZZ``. A continuació llistem algunes funcions pels enters:
     387
     388- Operacions bàsiques: ``+, -, *, /, ^`` (suma, resta, producte, quocient (possiblement racional) i potència).
     389- ``n // m`` (quocient de dividir `n` entre `m`)
     390- ``n % m`` (`n` mòdul `m`, el residu de dividir `n` entre `m`).
     391- ``divmod(a,b)`` (quocient i residu de dividir `a` entre `b`).
     392- ``abs(n)`` (valor absolut).
     393- ``randint(a,b)`` (un enter aleatori entre a i b, ambdós inclosos).
     394- ``random_prime(a)`` (un primer aleatori menor o igual que `a`).
     395- ``divisors(n)``, ``prime_divisors(n)``, ``number_of_divisors(n)`` (la seqüència de divisors de `n`, o només els divisors primers, o el nombre total de divisors).
     396- ``gcd(m,n)``, ``gcd(S)``, ``lcm(m,n)``, ``lcm(S)`` (el màxim comú divisor i el mínim comú múltiple de `m` i `n` o bé de la seqüència d'enters `S`).
     397- ``xgcd(m,n)`` (retorna tres valors `d`, `a` i `b` on `d` és el màxim comú divisor de `m` i `n` i on :math:`am+bn=d`).
     398- ``euler_phi(n)`` (el nombre d'unitats de l'anell :math:`\mathbb{Z}/n\mathbb{Z}`).
     399- ``factorial(n)`` (el factorial de l'enter `n`).
     400
     401Booleans
     402........
     403
     404- ``is_odd(i)``, ``is_even(i)`` retornen si l'enter `i` és senar (o parell).
     405- ``is_prime(i)``, ``is_prime_power(i)`` retornen si l'enter `i` és primer (o una potència d'un primer).
     406- ``is_square(n)`` retorna si l'enter `n` és un quadrat perfecte.
     407
     408Anells :math:`\mathbb{Z}/n\mathbb{Z}`
     409-------------------------------------
     410
     411L'anell de residus mòdul `n` el cridem amb  ``Integers(n)`` o amb ``Zmod(n)``.
     412Si posem ``R = Zmod(n)`` per algun `n` aleshores els elements de `R`
     413els cridem utilitzant ``R(1)``, ``R(2)``, etc.
     414Algunes funcions que ens poden ser útils són
     415
     416- Operacions bàsiques: ``+, -, *, ^``.
     417- ``inverse_mod(x,m)`` retorna l'invers de :math:`x \pmod{m}`.
     418- ``solve_mod(expr1 == expr2,m)`` resol equacions amb congruències; és important que les incògnites s'hagin alliberat abans, per exemple amb ``var('x')``. Per exemple:
     419
     420::
     421
     422    sage: x, y = var('x','y')
     423    sage: solve_mod(3*x + 2*y == 1, 5)
     424    [(0, 3), (1, 4), (2, 0), (3, 1), (4, 2)]
     425
     426- ``primitive_root(n)`` retorna un enter que genera el grup multiplicatiu dels enters mòdul `n`, si existeix.
     427- ``multiplicative_order(n)``, ``additive_order(n)`` retornen l'ordre multiplicatiu i additiu de l'enter `n`.
     428
     429
     430Booleans
     431........
     432
     433- ``is_field()`` determina si un conjunt és un cos.
     434- ``is_unit()`` determina si un element és invertible.
     435
     436L'exemple que segueix pot ser il·lustratiu::
     437
     438    sage: is_prime(19)
     439    True
     440    sage: primitive_root(19)
     441    2
     442    sage: Z19 = Zmod(19)
     443    sage: [x for x in Z19]
     444    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]
     445    sage: Z19(2).additive_order()
     446    19
     447    sage: Z19(2).multiplicative_order()
     448    18
     449    sage: Z19(5).multiplicative_order()
     450    9
     451    sage: Set([2^i % 19 for i in [1..18]])
     452    {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}
     453    sage: Set([5^i % 19 for i in [1..18]])
     454    {1, 4, 5, 6, 7, 9, 11, 16, 17}
     455
     456
     457Racionals
     458---------
     459
     460El cos dels nombres racionals es denota amb ``RationalField()`` o ``QQ``.
     461Algunes operacions que podem fer amb els racionals són
     462
     463- Operacions bàsiques: ``+, -, *, /, ^``.
     464- ``numerator(q)``, ``denominator(q)`` (el numerador i denominador de `q`).
     465
     466Reals
     467-----
     468
     469El cos dels reals el denotem  amb ``RealField()`` o ``RR``. Algunes funcions per als reals són:
     470
     471- Operacions bàsiques: ``+, -, *, /, ^``.
     472- ``ceil(r)``, ``floor(r)`` retorna la part entera superior o inferior de `r`.
     473- ``abs(r)`` retorna el valor absolut de `r`.
     474- ``sqrt(r)`` retorna l'arrel quadrada de `r`.
     475
     476Equacions
     477---------
     478
     479Es poden resoldre equacions utilitzant l'ordre ``solve()``. Escrivint ``?solve`` el sage ens dóna una explicació molt extensa. Aquí en repetim els primers exemples::
     480
     481    sage: x, y = var('x, y')
     482    sage: solve([x + y == 6, x - y == 4], x, y)
     483    [[x == 5, y == 1]]
     484    sage: solve([x^2 + y^2 == 1, y^2 == x^3 + x + 1], x, y)
     485    [[x == -1/2*I*sqrt(3) - 1/2, y == -sqrt(-1/2*I*sqrt(3) + 3/2)], [x == -1/2*I*sqrt(3) - 1/2, y == sqrt(-1/2*I*sqrt(3) + 3/2)], [x == 1/2*I*sqrt(3) - 1/2, y == -sqrt(1/2*I*sqrt(3) + 3/2)], [x == 1/2*I*sqrt(3) - 1/2, y == sqrt(1/2*I*sqrt(3) + 3/2)], [x == 0, y == -1], [x == 0, y == 1]]
     486    sage: solutions = solve([sqrt(x) + sqrt(y) == 5, x + y == 10], x, y,solution_dict = True); solutions
     487    [{x: -5/2*I*sqrt(5) + 5, y: 5/2*I*sqrt(5) + 5}, {x: 5/2*I*sqrt(5) + 5, y: -5/2*I*sqrt(5) + 5}]
     488    sage: for sol in solutions: print sol[x].n(digits=3), ",", sol[y].n(digits=3)
     489    5.00 - 5.59*I , 5.00 + 5.59*I
     490    5.00 + 5.59*I , 5.00 - 5.59*I
     491
     492Anell de polinomis
     493==================
     494
     495Definició de polinomis
     496----------------------
     497
     498Per generar l'anell de polinomis sobre un anell `R`
     499ho fem així:
     500
     501.. skip
     502
     503::
     504
     505    sage: P.<x> = PolynomialRing(R)
     506
     507A més, així queda definida `x` com la indeterminada dels polinomis de `P`.
     508Per escriure un polinomi de `P` ho podem fer
     509de dues maneres::
     510
     511    sage: P.<x> = PolynomialRing(QQ)
     512    sage: x^3-7*x^2+5
     513    x^3 - 7*x^2 + 5
     514    sage: P([5,0,-7,1])
     515    x^3 - 7*x^2 + 5
     516
     517Operacions
     518----------
     519
     520- Operacions bàsiques: ``+, -, *, /, ^``.
     521- ``f(a)`` per avaluar un polinomi `f` en `a`.
     522- ``f.degree()`` (el grau del polinomi).
     523- ``f.coeffs()`` retorna tots els coeficients de `f` mentre que ``f.coefficients()`` només retorna els coeficients no-nuls.
     524- ``f.leading_coefficient(f)`` retorna el coeficient principal de `f`.
     525- ``parent(f)`` ens diu on pertany el polinomi `f`.
     526- ``divmod(f,g)`` (quocient i residu de dividir `f` entre `g`), que es poden obtenir per separat amb ``f // g`` i ``f % g``.
     527-  ``gcd(f,g), xgcd(f,g), lcm(f,g)`` (vegeu l'apartat d'enters).
     528- ``factor(f)`` (la factorització de `f`).
     529- ``f.roots(f)``.
     530
     531Booleans
     532........
     533
     534- ``f.is_irreducible()`` retorna si `f` és irreductible.
     535- ``f.is_primitive()`` retorna si `f` és primitiu.
     536
     537Vegem un exemple::
     538
     539    sage: P.<x> = PolynomialRing(GF(49,'a'))
     540    sage: f = 4*x^5+5*x+2
     541    sage: g = x^8 + 6*x^7 + x^2
     542    sage: d,a,b = xgcd(f,g)
     543    sage: d
     544    1
     545    sage: d == a*f + b*g
     546    True
     547
     548Cossos finits
     549=============
     550
     551Construcció de cossos finits i extensions
     552-----------------------------------------
     553
     554Per crear el cos finit de `p^n` elements
     555escrivim:
     556
     557.. skip
     558
     559::
     560    sage: K = GF(p^n,'a')
     561
     562o bé:
     563
     564.. skip
     565
     566::
     567    sage: K.<a> = GF(p^n)
     568
     569Queda així definida també `a` com la classe de la indeterminada dels polinomis sobre :math:`F = \mathbb{Z}/p\mathbb{Z}` tal que :math:`K = F[x]/(f(x))`. Només podem obviar la variable `a` quan `n=1`.
     570
     571També podem definir cossos finits forçant un determinat polinomi `f` de l'anell de polinomis sobre :math:`\mathbb{Z}/p\mathbb{Z}` i de grau `n` utilitzant::
     572
     573.. skip
     574
     575::
     576    sage: F = GF(q, modulus = f)
     577
     578Donat un cos finit sempre podem conèixer-ne el cos primer
     579escrivint ``F.prime_subfield()``.
     580Si hem definit `F` com a extensió d'un cos `K`
     581direm que `K` és el cos base de `F` i el podrem conèixer escrivint
     582``F.base_ring()``.
     583Per a un cos que haguem definit directament es considera que el cos base és
     584el cos primer.
     585
     586Operacions
     587----------
     588- Operacions bàsiques: ``+, -, *, /, ^``.
     589- ``K.polynomial()`` retorna el polinomi que defineix `K`.
     590- ``b.minimal_polynomial()` (o ``b.minpoly()``) retorna el polinomi mínim de `b`.
     591- ``b.multiplicative_order()`` retorna l'ordre multiplicatiu, el mínim enter positiu `n` tal que :math:`b^n = 1`.
     592- ``len(K)`` és equivalent a ``K.cardinality()`` retorna el nombre d'elements del cos `K`.
     593- ``K.random_element()`` retorna un element aleatori de `K`.
     594
     595Booleans
     596........
     597
     598- ``f.is_primitive()`` retorna si `f` és un polinomi primitiu.
     599
     600
     601Algebra lineal
     602==============
     603
     604Construcció de vectors
     605----------------------
     606
     607Donat un cos `K`, creem l'espai vectorial
     608`K^n` mitjançant ``VectorSpace(K,n)``, o escrivint ``K^n``.
     609Per crear vectors podem fer una coerció dins l'espai dels vectors corresponent o bé els podem definir directament::
     610
     611    sage: K = GF(9,'a')
     612    sage: V3 = VectorSpace(K,3)
     613    sage: v = V3([1,0,1])
     614    sage: v
     615    (1, 0, 1)
     616    sage: v[1]
     617    0
     618
     619    sage: w = vector(K,[1,2,3])
     620    sage: w
     621    (1, 2, 0)
     622    sage: w[2]
     623    0
     624
     625Operacions
     626----------
     627
     628- Operacions bàsiques: ``+, -, *``.
     629- ``v.inner_product(w)`` (producte escalar),
     630- ``v.pairwise_product(w)`` (producte vectorial a :math:`K^3`).
     631
     632
     633Construcció de matrius
     634----------------------
     635
     636Donat un anell `R`, creem el conjunt de matrius
     637de `m` files i `n` columnes mitjançant ``MatrixSpace(R,m,n)``.
     638Per crear matrius podem fer una coerció dins l'espai de les matrius corresponent o bé les podem definir directament::
     639
     640    sage: F9.<alpha> = GF(9)
     641    sage: M = MatrixSpace(F9,2,3)
     642    sage: M([alpha, 2*alpha, 3*alpha, alpha, alpha^2, alpha^3])
     643    [      alpha     2*alpha           0]
     644    [      alpha   alpha + 1 2*alpha + 1]
     645    sage: matrix(2,3,[alpha,2*alpha,3*alpha,alpha,alpha^2,alpha^3])
     646    [      alpha     2*alpha           0]
     647    [      alpha   alpha + 1 2*alpha + 1]
     648    sage: matrix(3,2,[alpha,2*alpha,3*alpha,alpha,alpha^2,alpha^3])
     649    [      alpha     2*alpha]
     650    [          0       alpha]
     651    [  alpha + 1 2*alpha + 1]
     652
     653Si volem, podem especificar l'anell sobre el qual està definida una matriu.
     654Així, les dues ordres següents ens donarien matrius diferents:
     655
     656.. link
     657
     658::
     659    sage: m1 = matrix(Zmod(5),[[1,2],[3,4]]); m1
     660    [1 2]
     661    [3 4]
     662    sage: m2 = matrix(Zmod(7),[[1,2],[3,4]]); m2
     663    [1 2]
     664    [3 4]
     665    sage: m1 == m2
     666    False
     667
     668Per obtenir els elements d'una matriu `m` utilitzarem ``m[i,j]`` i per
     669obtenir les seves files utilitzarem ``m[i]``.
     670Seguint l'exemple anterior,
     671
     672.. link
     673
     674::
     675    sage: m = matrix(F9,[[alpha,2*alpha,3*alpha],[alpha,alpha^2,alpha^3]])
     676    sage: m[0,1]
     677    2*alpha
     678    sage: m[1]
     679    (alpha, alpha + 1, 2*alpha + 1)
     680
     681Per sumar, restar i multiplicar per escalars es fa amb
     682la notació usual. Per trobar la matriu inversa d'una
     683matriu invertible `m`
     684escriurem ``m^-1``.
     685
     686Per trobar les solucions d'un sistema lineal `x m=v` on
     687`m` és una matriu i `v` és un vector tenim  ``m.solve_left()``
     688mentre que per resoldre el sistema `x m=v` tenim
     689``m.solve_right()``. ::
     690
     691    sage: m=matrix(Integers(),[[0,1],[2,0]])
     692    sage: m
     693    [0 1]
     694    [2 0]
     695    sage: v=vector(Integers(),[2,2])
     696    sage: v
     697    (2, 2)
     698    sage: m.solve_left(v)
     699    (2, 1)
     700    sage: m.solve_right(v)
     701    (1, 2)
     702
     703També podem calcular submatrius. Per obtenir la submatriu :math:`3 \times 3` començant a l'entrada `(1,1)` d'una matriu :math:`4 \times 4`::
     704
     705          sage: m = matrix(4, [1..16])
     706          sage: m.submatrix(1, 1)
     707          [ 6  7  8]
     708          [10 11 12]
     709          [14 15 16]
     710
     711Ara només n'agafem dues files:
     712
     713.. link
     714
     715::
     716          sage: m.submatrix(1, 1, 2)
     717          [ 6  7  8]
     718          [10 11 12]
     719
     720I ara només una columna:
     721
     722.. link
     723
     724::
     725          sage: m.submatrix(1, 1, 2, 1)
     726          [ 6]
     727          [10]
     728
     729També es poden escollir `0` files o columnes:
     730
     731.. link
     732
     733::
     734          sage: m.submatrix(1, 1, 0)
     735          []
     736
     737Operacions amb matrius en general
     738---------------------------------
     739
     740- Operacions bàsiques: ``+, -, *``.
     741- ``A.nrows()`` i ``A.ncols()`` retorna el nombre de files i columnes de la matriu.
     742- ``m.transpose()`` retorna la matriu transposada.
     743- ``m.rank()``, ``m.kernel()``, ``m.image()`` retorna el rang, nucli i imatge de la matriu.
     744
     745Booleans
     746........
     747
     748- ``m.is_square()`` (per saber si la matriu és quadrada).
     749
     750Operacions amb matrius quadrades
     751--------------------------------
     752
     753- Operacions bàsiques: ``+, -, *, ^``.
     754- ``m.determinant()``, ``m.trace()`` i ``m.inverse()`` retorna el determinant, la traça i la inversa de la matriu (aquesta última, només en cas que existeixi).
     755
     756Booleans
     757........
     758
     759- ``m.is_symmetric()``, ``m.is_invertible()``, ``m.is_singular()`` (si la matriu  és simètrica, invertible o singular (és a dir, no invertible)).
     760- ``m.is_zero()``, ``m.is_one()`` (si la matriu és zero, o la matriu identitat).
     761
     762Càlcul diferencial
     763==================
     764
     765Amb Sage es poden calcular les derivades i integrals de moltes funcions. Per exemple, per
     766calcular la derivada de :math:`\sin(u)` respecte  :math:`u`, fem:
     767
     768::
     769
     770    sage: u = var('u')
     771    sage: diff(sin(u), u)
     772    cos(u)
     773
     774La quarta derivada de :math:`\sin(x^2)` s'obté mitjançant:
     775
     776::
     777
     778    sage: diff(sin(x^2), x, 4)
     779    16*x^4*sin(x^2) - 48*x^2*cos(x^2) - 12*sin(x^2)
     780
     781Per calcular les derivades parcials de :math:`x^2+17y^2` respecte
     782`x` i `y` fem:
     783
     784::
     785
     786    sage: x, y = var('x,y')
     787    sage: f = x^2 + 17*y^2
     788    sage: f.diff(x)
     789    2*x
     790    sage: f.diff(y)
     791    34*y
     792
     793També podem calcular integrals, tant definides com indefinides. Per calcular
     794:math:`\int x\sin(x^2)\, dx` i
     795:math:`\int_0^1 \frac{x}{x^2+1}\, dx` fem:
     796
     797::
     798
     799    sage: integral(x*sin(x^2), x)
     800    -1/2*cos(x^2)
     801    sage: integral(x/(x^2+1), x, 0, 1)
     802    1/2*log(2)
     803
     804També podem aconseguir una descomposició en fraccions parcials, per exemple de
     805:math:`\frac{1}{x^2-1}`:
     806
     807::
     808
     809    sage: f = 1/((1+x)*(x-1))
     810    sage: f.partial_fraction(x)
     811    1/2/(x - 1) - 1/2/(x + 1)
     812
     813
     814Gràfics
     815=======
     816
     817Amb Sage podem produir gràfics 2-D i 3-D.
     818
     819Gràfics bidimensionals
     820------------------------
     821
     822Podem dibuixar cercles, línies, polígons; gràfics de funcions en
     823coordenades cartesianes; i també en coordenades polars, corbes de nivell
     824i gràfics de camps vectorials. Podem trobar més exemples de les funcions
     825gràfiques del Sage a la documentació
     826`Sage Constructions <http://www.sagemath.org/doc/constructions/>`_
     827
     828
     829Per dibuixar un cercle groc de radi 1, centrat a l'origen, fem::
     830
     831    sage: circle((0,0), 1, rgbcolor=(1,1,0))
     832
     833I un cercle sòlid::
     834
     835    sage: circle((0,0), 1, rgbcolor=(1,1,0), fill=True)
     836
     837També podem assignar el cercle a una variable. Llavors no obtindrem cap dibuix::
     838
     839    sage: c = circle((0,0), 1, rgbcolor=(1,1,0))
     840
     841I el podem visualitzar mitjançant ``c.show()`` o ``show(c)``:
     842
     843.. link
     844
     845::
     846
     847    sage: c.show()
     848
     849L'ordre ``c.save('fitxer.png')`` desa el dibuix al disc.
     850
     851Amb l'opció ``aspect_ratio = 1`` podem aconseguir que els dos eixos estiguin
     852a la mateixa escala:
     853
     854.. link
     855
     856::
     857
     858    sage: c.show(aspect_ratio=1)
     859
     860També hauriem pogut utilitzar ``show(c, aspect_ratio=1)``, o desar-ho
     861amb l'ordre ``c.save('fitxer.png', aspect_ratio=1)``.
     862
     863Així obtenim el gràfic d'una funció bàsica:
     864
     865::
     866
     867    sage: plot(cos, (-5,5))
     868
     869Si primer alliberem una variable, podem obtenir gràfics de funcions paramètriques:
     870
     871::
     872
     873    sage: x = var('x')
     874    sage: parametric_plot((cos(x),sin(x)^3),(x,0,2*pi),rgbcolor=hue(0.6))
     875
     876
     877Podem combinar diversos gràfics en una de sol:
     878
     879::
     880
     881    sage: x = var('x')
     882    sage: p1 = parametric_plot((cos(x),sin(x)),(x,0,2*pi),rgbcolor=hue(0.2))
     883    sage: p2 = parametric_plot((cos(x),sin(x)^2),(x,0,2*pi),rgbcolor=hue(0.4))
     884    sage: p3 = parametric_plot((cos(x),sin(x)^3),(x,0,2*pi),rgbcolor=hue(0.6))
     885    sage: show(p1+p2+p3, axes=false)
     886
     887També podem crear polígons. Comencem amb una llista ``L`` de punts, i després
     888utilitzem la funció ``polygon`` per dibuixar el polígon que té aquests punts com
     889a frontera. Per exemple, un deltoide verd:
     890
     891::
     892
     893    sage: L = [[-1+cos(pi*i/100)*(1+cos(pi*i/100)),\
     894    ...   2*sin(pi*i/100)*(1-cos(pi*i/100))] for i in range(200)]
     895    sage: p = polygon(L, rgbcolor=(1/8,3/4,1/2))
     896    sage: p
     897
     898Si no volem veure els eixos, utilitzem ``show(p, axes=false)``.
     899
     900També podem afegir text a un gràfic:
     901
     902::
     903
     904    sage: L = [[6*cos(pi*i/100)+5*cos((6/2)*pi*i/100),\
     905    ...   6*sin(pi*i/100)-5*sin((6/2)*pi*i/100)] for i in range(200)]
     906    sage: p = polygon(L, rgbcolor=(1/8,1/4,1/2))
     907    sage: t = text("hipotrocoide", (5,4), rgbcolor=(1,0,0))
     908    sage: show(p+t)
     909
     910Un gràfic més complicat és el que mostra múltiples branques
     911de la funció arcsinus: és a dir, el gràfic de :math:`y=\sin(x)`
     912on :math:`x` entre :math:`-2\pi`
     913i :math:`2\pi`, i rotat un angle de 45 graus. Així és com ho
     914construirem en Sage:
     915
     916::
     917
     918    sage: v = [(sin(x),x) for x in srange(-2*float(pi),2*float(pi),0.1)]
     919    sage: line(v)
     920
     921Finalment, un exemple d'un gràfic de corbes de nivell:
     922
     923::
     924
     925    sage: f = lambda x,y: cos(x*y)
     926    sage: contour_plot(f, (-4, 4), (-4, 4))
     927
     928Gràfics tridimensionals
     929-------------------------
     930
     931També podem aconseguir gràfics 3-D amb Sage. Per defecte, aquests
     932gràfics es visualitzen amb el paquet [Jmol]_, que permet rotar i ampliar
     933l'objecte de manera interactiva, utilitzant el ratolí.
     934
     935Per visualitzar una funció de la forma `f(x,y) = z` utilitzem ``plot3d``:
     936
     937::
     938
     939    sage: x, y = var('x,y')
     940    sage: plot3d(x^2 + y^2, (x,-2,2), (y,-2,2))
     941
     942També podem utilitzar ``parametric_plot3d`` per visualitzar
     943una superfície paramètrica on cadascuna de les coordenades `x, y, z`
     944ve determinada per una funció d'una o dues variables (normalment
     945denotades per `u` i `v`). Així, el gràfic anterior també es pot visualitzar
     946paramètricament de la manera següent:
     947
     948::
     949
     950    sage: u, v = var('u, v')
     951    sage: f_x(u, v) = u
     952    sage: f_y(u, v) = v
     953    sage: f_z(u, v) = u^2 + v^2
     954    sage: parametric_plot3d([f_x, f_y, f_z], (u, -2, 2), (v, -2, 2))
     955
     956Finalment, podem utilitzar ``implicit_plot3d``,
     957per visualitzar les corbes de nivell d'una funció com `f(x, y, z)`. Aquesta
     958ordre visualitza una esfera utilitzant la fórmula clàssica:
     959
     960::
     961
     962    sage: x, y, z = var('x, y, z')
     963    sage: implicit_plot3d(x^2 + y^2 + z^2 - 4, (x,-2, 2), (y,-2, 2), (z,-2, 2))
     964
     965Índexs i taules
     966===============
     967
     968..  [Jmol] Jmol: un visualitzador d'estructures químiques en 3D, de codi obert i escrit en Java.  http://www.jmol.org/.
     969
     970* :ref:`genindex`
     971* :ref:`search`
     972