Sage is an actively used programming language created in 2005.

 14Years Old 3,978Users 0Jobs

### Example code from Linguist:

```# -*- coding: utf-8 -*-
#
#   Funciones en Python/Sage para el trabajo con polinomios con una
#   incógnita (x).
#
#   Copyright (C) 2014-2015, David Abián <davidabian [at] davidabian.com>
#
#   This program is free software: you can redistribute it and/or modify it
#   Software Foundation, either version 3 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, see <http://www.gnu.org/licenses/>.

"""Devuelve la lista de polinomios constantes y no constantes de
"""
lpols = []
var('x')
xs = vector([(x^i) for i in range(grado+1)])
lpols = [cs*xs for cs in V]
if mostrar:
for pol in lpols:
print pol
return lpols

"""Devuelve la lista de polinomios no constantes de coeficientes mónicos y
"""
lpols = []
var('x')
xs = vector([(x^i) for i in range(grado+1)])
lpols += [cs*xs]
if mostrar:
for pol in lpols:
print pol
return lpols

"""Devuelve la lista de polinomios de coeficientes mónicos del grado
"""
lpols = []
var('x')
if cs[0] != 0: # polinomios del mismo grado
lpols += [cs*xs]
if mostrar:
for pol in lpols:
print pol
return lpols

def excluirReducibles (lpols=[], mostrar=False):
"""Filtra una lista dada de polinomios de coeficientes mónicos y devuelve
aquellos irreducibles.
"""
var('x')
irreds = []
for p in lpols:
fp = (p.factor_list())
if len(fp) == 1 and fp[0][1] == 1:
irreds += [p]
if mostrar:
for pol in irreds:
print pol
return irreds

def vecPol (vec=random_vector(GF(2),0)):
"""Transforma los coeficientes dados en forma de vector en el polinomio
que representan.

Por ejemplo, con vecPol(vector([1,0,3,1])) se obtiene x³ + 3*x + 1.

Para la función opuesta, véase polVec().
"""
var('x')
xs = vector([x^(len(vec)-1-i) for i in range(len(vec))])
return vec*xs

def polVec (p=None):
"""Devuelve el vector de coeficientes del polinomio dado que acompañan a la
incógnita x, de mayor a menor grado.

Por ejemplo, con polVec(x^3 + 3*x + 1) se obtiene el vector (1, 0, 3, 1).

Para la función opuesta, véase vecPol().
"""
cs = []
if p != None:
var('x')
p(x) = p
for i in [0..p(x).degree(x)]:
cs.append(p(x).coefficient(x,i))
cs = list(reversed(cs))
return vector(cs)

def completar2 (p=0):
grado 2 y lo devuelve en su nueva forma.

Si el polinomio dado no es válido, devuelve 0.

Por ejemplo, con complCuad(3*x^2 + 12*x + 5) se obtiene 3*(x + 2)^2 - 7.
"""
var('x')
p(x) = p.expand()
if p(x).degree(x) != 2:
p(x) = 0
else:
cs = polVec(p(x))
p(x) = cs[0]*(x+(cs[1]/(2*cs[0])))^2+(4*cs[0]*cs[2]-cs[1]^2)/(4*cs[0])
return p(x)
```

### Example code from Wikipedia:

```sage: E2 = EllipticCurve(CC, [0,0,-2,1,1])
sage: E2
Elliptic Curve defined by y^2 + (-2.00000000000000)*y =
x^3 + 1.00000000000000*x + 1.00000000000000 over
Complex Field with 53 bits of precision
sage: E2.j_invariant()
61.7142857142857```
Edit

Last updated February 11th, 2019