def only_best_table(self, compare_to=None):
counting = self._counting_tournaments
#row_header = ["Pos", "Pts", "#Tourn", "Team name", "Region"]
#row_header += ['Best', '2nd best', '3rd best', '4th best (does not count)']
row_header = ["Pos"]
if compare_to:
row_header += ['Official']
row_header += ["Pts", "Team name"]
row_header += ['Best', '2nd best', '3rd best', '4th best'][:counting]
row_header += ['Provenance']
rows = [row_header]
L = self._equipes.values()
L.sort(reverse=True)
for i, e in enumerate(L):
row = [i+1]
if compare_to:
pos = compare_to.index(e._nom)
move = pos - i
row.append("{} ({})".format(pos+1, move))
row.append(e.total())
#row.append(e.nb_tournois_participes())
row.append(e._nom)
bests = ["%s (%s) %s" % b for b in e.four_best()]
if len(bests) < 4:
bests += [""] * (4-len(bests))
row.extend(bests[:counting])
row.append(e.provenance())
rows.append(row)
return table(rows=rows,header_row=True)
def statistiques_participation_table(self):
L = [e.nb_tournois_participes() for e in self._equipes.values()]
M = max(L)
rows = [("Number of tournaments played", "Number of teams")]
for i in range(1, M+1):
rows.append( (i, L.count(i)) )
return table(rows=rows, header_row=True)
def projection_graph(G, proj_fn, filename=None, verbose=False):
r"""
Return the image of a graph under a function on vertices.
INPUT:
- ``G`` -- graph
- ``proj_fn`` -- function
- ``filename`` -- integer (default:``None``), save the graph to this pdf
filename if filename is not None
- ``verbose`` -- bool (default:``False``), print a table of data about the
projection
EXAMPLES::
sage: from slabbe.graph import projection_graph
sage: g = graphs.PetersenGraph()
sage: g.vertices()
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
sage: f = lambda i: i % 5
sage: projection_graph(g, f)
Looped multi-digraph on 5 vertices
With verbose information::
sage: projection_graph(g, lambda i:i%4, verbose=True)
Number of vertices Projected vertices
+--------------------+--------------------+
2 3
2 2
3 1
3 0
Looped multi-digraph on 4 vertices
"""
edges = set((proj_fn(A),proj_fn(B)) for A,B,_ in G.edges())
G_proj = DiGraph(edges, format='list_of_edges', loops=True, multiedges=True)
if verbose:
d = dict(Counter(proj_fn(s) for s in G.vertices()))
rows = [(value, key) for key,value in d.iteritems()]
rows.sort(reverse=True,key=lambda row:row[1])
header_row = ['Number of vertices', 'Projected vertices']
from sage.misc.table import table
print table(rows=rows, header_row=header_row)
if filename:
from slabbe import TikzPicture
print TikzPicture.from_graph(G_proj, prog='dot').pdf(filename)
return G_proj
def test_packages(packages, only_failures=False):
"""
Return list of all installed packages.
INPUT:
- ``packages`` -- a list/tuple/iterable of strings. The names of
GAP packages to try to import.
- ``only_failures`` -- boolean, default ``False``. Whether to only
include failures in the table.
OUTPUT:
A table of the installed packages and whether they load
successfully.
EXAMPLES::
sage: from sage.tests.gap_packages import all_installed_packages, test_packages
sage: test_packages(['GAPDoc'])
Status Package GAP Output
+--------+---------+------------+
GAPDoc true
All packages, including user-installed ones::
sage: pkgs = all_installed_packages()
sage: test_packages(pkgs) # random output
Status Package GAP Output
+---------+------------+------------+
Alnuth true
GAPDoc true
Failure HAPcryst fail
Hap true
autpgrp true
braid true
crime true
ctbllib true
design true
factint true
grape true
guava true
laguna true
polycyclic true
polymaking true
sonata true
toric true
"""
rows = [['Status', 'Package', 'GAP Output']]
for pkg in packages:
output = libgap.eval('LoadPackage("{0}")'.format(pkg))
ok = bool(output)
status = '' if ok else 'Failure'
if ok and only_failures:
continue
rows.append([status, pkg, str(output)])
from sage.misc.table import table
return table(rows, header_row=True)
def test_packages(packages, only_failures=False):
"""
Return list of all installed packages.
INPUT:
- ``packages`` -- a list/tuple/iterable of strings. The names of
GAP packages to try to import.
- ``only_failures`` -- boolean, default ``False``. Whether to only
include failures in the table.
OUTPUT:
A table of the installed packages and whether they load
successfully.
EXAMPLES::
sage: from sage.tests.gap_packages import all_installed_packages, test_packages
sage: test_packages(['GAPDoc'])
Status Package GAP Output
+--------+---------+------------+
GAPDoc true
All packages, including user-installed ones::
sage: pkgs = all_installed_packages()
sage: test_packages(pkgs) # random output
Status Package GAP Output
+---------+------------+------------+
Alnuth true
GAPDoc true
Failure HAPcryst fail
Hap true
autpgrp true
braid true
crime true
ctbllib true
design true
factint true
grape true
guava true
laguna true
polycyclic true
polymaking true
sonata true
toric true
"""
rows = [['Status', 'Package', 'GAP Output']]
for pkg in packages:
output = libgap.eval('LoadPackage("{0}")'.format(pkg))
ok = bool(output)
status = '' if ok else 'Failure'
if ok and only_failures:
continue
rows.append([status, pkg, str(output)])
from sage.misc.table import table
return table(rows, header_row=True)
def equipe_alphabetiquement_table(self):
L = self._equipes.keys()
rows = []
for nom in sorted(L):
equipe = self._equipes[nom]
tournois = ", ".join([T.long_name() for T in equipe._positions.keys()])
rows.append(( nom.ljust(40), equipe.provenance(), tournois))
return table(rows=rows)
def tournaments_stat_table(self):
rows = [("Tournaments considered", "Points for champion", "#teams getting points",
"#teams", "Strength")]
for T in self._tournois:
scale = self._scales[T._scale_id]
rows.append( (T.long_name(), scale[1], len(scale)-1,
self._tournament_size(T),
"5/%s and %s/20"%(self._strength5(T), self._strength20(T))))
return table(rows=rows,header_row=True)
def number_of_inversions_table(self, top=32):
rows = [("Tournoi", "Nombre d'inversions")]
tot = 0
for tournoi in self._tournois:
move_list = self._moves[tournoi]
#print tournoi, move_list[:top]
moves = sum(abs(a) for a in move_list[:top])
rows.append((tournoi, moves))
tot += moves
rows.append(('Total', tot))
return table(rows=rows, header_row=True)
def lyapunov_table(algo, n_orbits, n_iterations=1000):
r"""
Return a table of values of Lyapunov exponents for this algorithm.
INPUT:
- ``n_orbits`` -- integer, number of orbits
- ``n_iterations`` -- integer, length of each orbit
OUTPUT:
table of liapounov exponents
EXAMPLES::
sage: from slabbe.mult_cont_frac import Brun
sage: from slabbe.lyapunov import lyapunov_table
sage: lyapunov_table(Brun(), 10, 1000000) # random
10 succesfull orbits min mean max std
+-----------------------+---------+---------+---------+---------+
$\theta_1$ 0.303 0.305 0.307 0.0013
$\theta_2$ -0.1131 -0.1124 -0.1115 0.00051
$1-\theta_2/\theta_1$ 1.3678 1.3687 1.3691 0.00043
"""
import numpy as np
from sage.misc.functional import numerical_approx
from sage.functions.other import abs, floor
from sage.functions.log import log
from sage.misc.table import table
rep = lyapunov_sample(algo, n_orbits, n_iterations)
def my_log(number):
return floor(log(abs(number), 10.))
def my_rounded(number, s):
m = my_log(number)
return numerical_approx(number, digits=m - s + 1)
names = [r"$\theta_1$", r"$\theta_2$", r"$1-\theta_2/\theta_1$"]
rows = []
for i, data in enumerate(rep):
data = np.array(data)
s = my_log(data.std())
row = [names[i]]
row.append(my_rounded(data.min(), s))
row.append(my_rounded(data.mean(), s))
row.append(my_rounded(data.max(), s))
row.append(my_rounded(data.std(), s))
rows.append(row)
header = [
'{} succesfull orbits'.format(len(rep[0])), 'min', 'mean', 'max', 'std'
]
return table(rows=rows, header_row=header)
def mult_cont_frac_vs_dirichlet(v, dirichlet, algos):
r"""
Returns the indices i such that dirichlet approximations appears as columns
of the i-th matrix obtained from mult. dim. cont. frac. algorithms.
INPUT:
- ``v`` -- list of real numbers
- ``dirichlet`` -- list, first dirichlet approximations
- ``algos`` -- list, list of mult. cont. frac. algorithms
OUTPUT:
table
EXAMPLES::
sage: from slabbe.diophantine_approx import best_simultaneous_convergents
sage: from slabbe.diophantine_approx import mult_cont_frac_vs_dirichlet
sage: from slabbe.mult_cont_frac import Brun,ARP,Reverse,Selmer,Cassaigne
sage: v = [e, pi]
sage: it = best_simultaneous_convergents(v)
sage: dirichlet = [next(it) for _ in range(10)]
sage: algos = [Brun(), ARP(), Reverse(), Selmer(),Cassaigne()]
sage: mult_cont_frac_vs_dirichlet(v, dirichlet, algos)
Dirichlet Brun ARP Reverse Selmer Cassaigne
+-----------------------------+----------+----------+---------+----------+-----------+
(3, 3, 1) [4, 5] [3] [] [8, 12] []
(19, 22, 7) [9, 16] [6, 11] [7, 33] [32] [15, 25]
(1843, 2130, 678) [22, 27] [16, 17] [] [44, 48] [36, 39]
(51892, 59973, 19090) [] [] [] [56] []
(113018, 130618, 41577) [] [] [] [] []
(114861, 132748, 42255) [33, 35] [22, 24] [] [62, 66] [51, 53]
(166753, 192721, 61345) [] [] [] [] []
(446524, 516060, 164267) [36] [25] [] [] [56, 57]
(1174662, 1357589, 432134) [39, 44] [26, 29] [] [68] [61, 66]
(3970510, 4588827, 1460669) [] [28] [] [] []
"""
D = mult_cont_frac_vs_dirichlet_dict(v, dirichlet, algos)
rows = []
for v in dirichlet:
v = tuple(v)
row = [v]
for algo in algos:
indices = D[algo][v]
if len(indices) > 1:
row.append([min(indices), max(indices)])
else:
row.append(indices)
rows.append(row)
header_row = ['Dirichlet'] + [algo.class_name() for algo in algos]
from sage.misc.table import table
return table(rows=rows, header_row=header_row)
def full_table(self):
L = self.sorted_team_list()
title = ["Division", "Position", "Équipe", "Provenance"]
title += ["Pos", "Pts", 'ES'] * len(self._tournois)
title += ["Total", "Variation"]
rows = []
rows.append(title)
for i, e in enumerate(L):
row = [self.division(i+1), i+1, e._nom, e.provenance()]
row += e.pos_pts_es_ordonnes(self._tournois)
row += [e.total(), self.get_move_str(e)]
rows.append(row)
return table(rows=rows,header_row=True)
def projection_graph(G, proj_fn, filename=None, verbose=False):
r"""
Return the image of a graph under a function on vertices.
INPUT:
- ``G`` -- graph
- ``proj_fn`` -- function
- ``filename`` -- integer (default:``None``), save the graph to this pdf
filename if filename is not None
- ``verbose`` -- bool (default:``False``), print a table of data about the
projection
EXAMPLES::
sage: from slabbe.graph import projection_graph
sage: g = graphs.PetersenGraph()
sage: g.vertices()
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
sage: f = lambda i: i % 5
sage: projection_graph(g, f)
Looped multi-digraph on 5 vertices
With verbose information::
sage: projection_graph(g, lambda i:i%4, verbose=True)
Number of vertices Projected vertices
+--------------------+--------------------+
2 3
2 2
3 1
3 0
Looped multi-digraph on 4 vertices
"""
edges = set((proj_fn(A),proj_fn(B)) for A,B,_ in G.edges())
G_proj = DiGraph(edges, format='list_of_edges', loops=True, multiedges=True)
if verbose:
d = dict(Counter(proj_fn(s) for s in G.vertices()))
rows = [(value, key) for key,value in d.iteritems()]
rows.sort(reverse=True,key=lambda row:row[1])
header_row = ['Number of vertices', 'Projected vertices']
from sage.misc.table import table
print(table(rows=rows, header_row=header_row))
if filename:
from slabbe import TikzPicture
print(TikzPicture.from_graph(G_proj, prog='dot').pdf(filename))
return G_proj
def lyapunov_table(algo, n_orbits, n_iterations=1000):
r"""
Return a table of values of Lyapunov exponents for this algorithm.
INPUT:
- ``n_orbits`` -- integer, number of orbits
- ``n_iterations`` -- integer, length of each orbit
OUTPUT:
table of liapounov exponents
EXAMPLES::
sage: from slabbe.mult_cont_frac import Brun
sage: from slabbe.lyapunov import lyapunov_table
sage: lyapunov_table(Brun(), 10, 1000000) # random
10 succesfull orbits min mean max std
+-----------------------+---------+---------+---------+---------+
$\theta_1$ 0.303 0.305 0.307 0.0013
$\theta_2$ -0.1131 -0.1124 -0.1115 0.00051
$1-\theta_2/\theta_1$ 1.3678 1.3687 1.3691 0.00043
"""
import numpy as np
from sage.misc.functional import numerical_approx
from sage.rings.real_mpfr import RR
from sage.misc.table import table
rep = lyapunov_sample(algo, n_orbits, n_iterations)
def floor_log(number):
return RR(number).abs().log10().floor()
def my_rounded(number, s):
m = floor_log(number)
return numerical_approx(number, digits=m-s+1)
names = [r"$\theta_1$", r"$\theta_2$", r"$1-\theta_2/\theta_1$"]
rows = []
for i, data in enumerate(rep):
data = np.array(data)
s = floor_log(data.std())
row = [names[i]]
row.append(my_rounded(data.min(),s))
row.append(my_rounded(data.mean(),s))
row.append(my_rounded(data.max(),s))
row.append(my_rounded(data.std(),s))
rows.append(row)
header = ['{} succesfull orbits'.format(len(rep[0])), 'min','mean','max','std']
return table(rows=rows,header_row=header)
def _repr_(self):
r"""
Return as string representation of ``self``.
OUTPUT:
A string.
EXAMPLES::
sage: rays = [(1,0), (1,1), (1,2), (-1,-1)]
sage: F1 = FilteredVectorSpace(rays, {0:[1, 2], 2:[3]})
sage: F2 = FilteredVectorSpace(rays, {0:[1, 2], oo:[3]})
sage: F3 = FilteredVectorSpace(rays, {oo:[3]})
sage: F4 = FilteredVectorSpace(rays, {0:[3]})
sage: MultiFilteredVectorSpace({'a':F1, 'b':F2, 'c': F3, 'd': F4})
Filtrations
a: QQ^2 >= QQ^1 >= QQ^1 >= 0
b: QQ^2 >= QQ^1 >= QQ^1 >= QQ^1
c: QQ^1 >= QQ^1 >= QQ^1 >= QQ^1
d: QQ^1 >= 0 >= 0 >= 0
sage: MultiFilteredVectorSpace(123, base_ring=RR)
Unfiltered RR^123
"""
if not self._filt:
F = FilteredVectorSpace(self.dimension(),
base_ring=self.base_ring())
return 'Unfiltered ' + repr(F)
rows = []
support = self.support()
min_deg, max_deg = self.min_degree(), self.max_degree()
for key in sorted(self.index_set()):
F = self.get_filtration(key)
r = [str(key)] + F._repr_degrees(min_deg, max_deg-1)
rows.append(r)
from sage.misc.table import table
t = table(rows)
w = t._widths()
lines = ['Filtrations']
for r in rows:
s = ' '
s += r[0].rjust(w[0]) + ': '
s += ' >= '.join(r[i].center(w[i]) for i in range(1, len(w)))
lines.append(s)
return '\n'.join(lines)
def _repr_(self):
r"""
Return as string representation of ``self``.
OUTPUT:
A string.
EXAMPLES::
sage: rays = [(1,0), (1,1), (1,2), (-1,-1)]
sage: F1 = FilteredVectorSpace(rays, {0:[1, 2], 2:[3]})
sage: F2 = FilteredVectorSpace(rays, {0:[1, 2], oo:[3]})
sage: F3 = FilteredVectorSpace(rays, {oo:[3]})
sage: F4 = FilteredVectorSpace(rays, {0:[3]})
sage: MultiFilteredVectorSpace({'a':F1, 'b':F2, 'c': F3, 'd': F4})
Filtrations
a: QQ^2 >= QQ^1 >= QQ^1 >= 0
b: QQ^2 >= QQ^1 >= QQ^1 >= QQ^1
c: QQ^1 >= QQ^1 >= QQ^1 >= QQ^1
d: QQ^1 >= 0 >= 0 >= 0
sage: MultiFilteredVectorSpace(123, base_ring=RR)
Unfiltered RR^123
"""
if not self._filt:
F = FilteredVectorSpace(self.dimension(),
base_ring=self.base_ring())
return 'Unfiltered ' + repr(F)
rows = []
support = self.support()
min_deg, max_deg = self.min_degree(), self.max_degree()
for key in sorted(self.index_set()):
F = self.get_filtration(key)
r = [str(key)] + F._repr_degrees(min_deg, max_deg - 1)
rows.append(r)
from sage.misc.table import table
t = table(rows)
w = t._widths()
lines = ['Filtrations']
for r in rows:
s = ' '
s += r[0].rjust(w[0]) + ': '
s += ' >= '.join(r[i].center(w[i]) for i in range(1, len(w)))
lines.append(s)
return '\n'.join(lines)
def check_integrals_of_motion(self, affine_parameter, solution_key=None):
r"""
Check the constancy of the four integrals of motion
INPUT:
- ``affine_parameter`` -- value of the affine parameter `\lambda`
- ``solution_key`` -- (default: ``None``) string denoting the numerical
solution to use for evaluating the various integrals of motion;
if ``None``, the latest solution computed by :meth:`integrate` is
used.
OUTPUT:
- a `SageMath table <https://doc.sagemath.org/html/en/reference/misc/sage/misc/table.html>`_
with the absolute and relative differences with respect to the
initial values.
"""
CF = ComplexField(16)
lambda_min = self.domain().lower_bound()
res = [[
"quantity", "value", "initial value", "diff.", "relative diff."
]]
mu = self.evaluate_mu(affine_parameter, solution_key=solution_key)
mu0 = self.evaluate_mu(lambda_min, solution_key=solution_key)
diff = mu - mu0
rel_diff = CF(diff / mu0) if mu0 != 0 else "-"
res.append([r"$\mu$", mu, mu0, CF(diff), rel_diff])
E = self.evaluate_E(affine_parameter, solution_key=solution_key)
E0 = self.evaluate_E(lambda_min, solution_key=solution_key)
diff = E - E0
rel_diff = CF(diff / E0) if E0 != 0 else "-"
res.append([r"$E$", E, E0, CF(diff), rel_diff])
L = self.evaluate_L(affine_parameter, solution_key=solution_key)
L0 = self.evaluate_L(lambda_min, solution_key=solution_key)
diff = L - L0
rel_diff = CF(diff / L0) if L0 != 0 else "-"
res.append([r"$L$", L, L0, CF(diff), rel_diff])
Q = self.evaluate_Q(affine_parameter, solution_key=solution_key)
Q0 = self.evaluate_Q(lambda_min, solution_key=solution_key)
diff = Q - Q0
rel_diff = CF(diff / Q0) if Q0 != 0 else "-"
res.append([r"$Q$", Q, Q0, CF(diff), rel_diff])
return table(res, align="center")
def table(self):
r"""
EXAMPLES::
sage: from slabbe.ranking_scale import RankingScale_CQU4_2011
sage: R = RankingScale_CQU4_2011()
sage: R.table()
Position Grand Chelem Mars Attaque La Flotte Petit Chelem
1 1000 1000 800 400
2 938 938 728 355
3 884 884 668 317
4 835 835 614 285
5 791 791 566 256
6 750 750 522 230
7 711 711 482 206
8 675 675 444 184
9 641 641 409 164
10 609 609 377 146
...
95 0 11 0 0
96 0 10 0 0
97 0 9 0 0
98 0 8 0 0
99 0 7 0 0
100 0 6 0 0
101 0 4 0 0
102 0 3 0 0
103 0 2 0 0
104 0 1 0 0
"""
from sage.misc.table import table
rows = []
M = self.length()
names = ('Position',) + self._scale_names
scales = (range(M),) + self._scales
rows.append(names)
Z = itertools.izip_longest(*scales, fillvalue=0)
Z.next() # enlever la premiere ligne de zeros
rows.extend(Z)
return table(rows)
def table(self, p, i1, i2, j1, j2):
r"""
Return a table printing the groups in the ``p`` page.
INPUT:
- ``p`` -- the page to print.
-- ``i1`` -- the first column to print.
-- ``i2`` -- the last column to print.
-- ``j1`` -- the first row to print.
-- ``j2`` -- the last row to print.
EXAMPLES::
sage: from sage.interfaces.kenzo import Sphere # optional -- kenzo
sage: S2 = Sphere(2) # optional -- kenzo
sage: EMS = S2.em_spectral_sequence() # optional -- kenzo
sage: EMS.table(0, -2, 2, -2, 2) # optional -- kenzo
0 Z 0 0 0
0 0 0 0 0
0 0 Z 0 0
0 0 0 0 0
0 0 0 0 0
"""
from sage.misc.table import table
groups = []
for j in range(j2 - j1 + 1):
row = []
for i in range(i1, i2 + 1):
group = self.group(p, i, j2 - j)
if group.invariants():
row.append(group.short_name())
else:
row.append('0')
groups.append(row)
return table(groups)
def table(self):
r"""
EXAMPLES::
sage: from slabbe.ranking_scale import RankingScale_CQU4_2011
sage: R = RankingScale_CQU4_2011()
sage: R.table()
Position Grand Chelem Mars Attaque La Flotte Petit Chelem
1 1000 1000 800 400
2 938 938 728 355
3 884 884 668 317
4 835 835 614 285
5 791 791 566 256
6 750 750 522 230
7 711 711 482 206
8 675 675 444 184
9 641 641 409 164
10 609 609 377 146
...
95 0 11 0 0
96 0 10 0 0
97 0 9 0 0
98 0 8 0 0
99 0 7 0 0
100 0 6 0 0
101 0 4 0 0
102 0 3 0 0
103 0 2 0 0
104 0 1 0 0
"""
from sage.misc.table import table
rows = []
M = self.length()
names = ('Position', ) + self._scale_names
scales = (range(M), ) + self._scales
rows.append(names)
Z = itertools.izip_longest(*scales, fillvalue=0)
Z.next() # enlever la premiere ligne de zeros
rows.extend(Z)
return table(rows)
def lyapunov_comparison_table(L, n_orbits=100, n_iterations=10000):
r"""
Return a table of values of Lyapunov exponents for many algorithm.
INPUT:
- ``L`` -- list of algorithms
- ``n_orbits`` -- integer
- ``n_iterations`` -- integer
OUTPUT:
table
EXAMPLES::
sage: import slabbe.mult_cont_frac as mcf
sage: from slabbe.lyapunov import lyapunov_comparison_table
sage: algos = [mcf.Brun(), mcf.ARP()]
sage: lyapunov_comparison_table(algos) # abs tol 0.01
Algorithm \#Orbits $\theta_1$ (std) $\theta_2$ (std) $1-\theta_2/\theta_1$ (std)
+-------------------------+----------+------------------+------------------+-----------------------------+
Arnoux-Rauzy-Poincar\'e 100 0.44 (0.012) -0.172 (0.0060) 1.388 (0.0054)
Brun 100 0.30 (0.011) -0.113 (0.0049) 1.370 (0.0070)
"""
rows = []
for algo in L:
try:
row = _lyapunov_row(algo, n_orbits, n_iterations)
except Exception as err:
s = "{}: {}".format(err.__class__.__name__, err)
print("Ignoring {} in Lyapunov table. {}".format(
algo.class_name(), s))
else:
rows.append(row)
rows.sort(key=lambda d: d[4], reverse=True)
header = ("Algorithm", r"\#Orbits", r"$\theta_1$ (std)",
r"$\theta_2$ (std)", r"$1-\theta_2/\theta_1$ (std)")
return table(rows=rows, header_row=header)
def lyapunov_comparison_table(L, n_orbits=100, n_iterations=10000):
r"""
Return a table of values of Lyapunov exponents for many algorithm.
INPUT:
- ``L`` -- list of algorithms
- ``n_orbits`` -- integer
- ``n_iterations`` -- integer
OUTPUT:
table
EXAMPLES::
sage: import slabbe.mult_cont_frac as mcf
sage: from slabbe.lyapunov import lyapunov_comparison_table
sage: algos = [mcf.Brun(), mcf.ARP()]
sage: lyapunov_comparison_table(algos) # abs tol 0.01
Algorithm \#Orbits $\theta_1$ (std) $\theta_2$ (std) $1-\theta_2/\theta_1$ (std)
+-------------------------+----------+------------------+------------------+-----------------------------+
Arnoux-Rauzy-Poincar\'e 100 0.44 (0.012) -0.172 (0.0060) 1.388 (0.0054)
Brun 100 0.30 (0.011) -0.113 (0.0049) 1.370 (0.0070)
"""
rows = []
for algo in L:
try:
row = _lyapunov_row(algo, n_orbits, n_iterations)
except Exception as err:
s = "{}: {}".format(err.__class__.__name__, err)
print("Ignoring {} in Lyapunov table. {}".format(algo.class_name(), s))
else:
rows.append(row)
rows.sort(key=lambda d:d[4], reverse=True)
header = ("Algorithm", r"\#Orbits", r"$\theta_1$ (std)", r"$\theta_2$ (std)",
r"$1-\theta_2/\theta_1$ (std)")
return table(rows=rows, header_row=header)
def test_packages(packages, only_failures=False):
"""
Return list of all installed packages.
INPUT:
- ``packages`` -- a list/tuple/iterable of strings. The names of
GAP packages to try to import.
- ``only_failures`` -- boolean, default ``False``. Whether to only
include failures in the table.
OUTPUT:
A table of the installed packages and whether they load
successfully.
EXAMPLES::
sage: from sage.tests.gap_packages import all_installed_packages, test_packages
sage: test_packages(['GAPDoc'])
Status Package GAP Output
+--------+---------+------------+
GAPDoc true
All packages, including user-installed ones::
sage: pkgs = all_installed_packages()
sage: test_packages(pkgs) # random output
Status Package GAP Output
+---------+------------+------------+
Alnuth true
GAPDoc true
HAPcryst true
Hap true
QPA true
aclib true
atlasrep true
autpgrp true
cohomolo true
corelg true
crime true
cryst true
crystcat true
ctbllib true
design true
factint true
gbnp true
grape true
guava true
happrime true
hecke true
laguna true
liealgdb true
liepring true
liering true
loops true
mapclass true
polycyclic true
polymaking true
quagroup true
repsn true
sla true
sonata true
tomlib true
toric true
"""
rows = [['Status', 'Package', 'GAP Output']]
for pkgdir in packages:
# to allow weird suffixes e.g. 'qpa-version'
pkg = pkgdir.split('-')[0]
orig_warning_level = libgap.InfoLevel(libgap.InfoWarning)
# Silence warnings about missing optional packages that might occur
# when loading packages; they're not important for the purposes of this
# test code
libgap.SetInfoLevel(libgap.InfoWarning, 0)
try:
output = libgap.LoadPackage(pkg)
finally:
# Restore the original warning level
libgap.SetInfoLevel(libgap.InfoWarning, orig_warning_level)
ok = bool(output)
status = '' if ok else 'Failure'
if ok and only_failures:
continue
rows.append([status, pkg, str(output)])
from sage.misc.table import table
return table(rows, header_row=True)
def dirichlet_convergents_dependance(v, n, verbose=False):
r"""
INPUT:
- ``v`` -- list of real numbers
- ``n`` -- integer, number of iterations
- ``verbose`` -- bool (default: ``False``),
OUTPUT:
- table of linear combinaisons of dirichlet approximations in terms of
previous dirichlet approximations
EXAMPLES::
sage: from slabbe.diophantine_approx import dirichlet_convergents_dependance
sage: dirichlet_convergents_dependance([e,pi], 4)
i vi lin. rec. remainder
+---+-----------------------+-------------+-----------+
0 (3, 3, 1) [] (3, 3, 1)
1 (19, 22, 7) [6] (1, 4, 1)
2 (1843, 2130, 678) [96, 6] (1, 0, 0)
3 (51892, 59973, 19090) [28, 15, 1] (0, 0, 0)
The last 3 seems enough::
sage: dirichlet_convergents_dependance([e,pi], 8)
i vi lin. rec. remainder
+---+--------------------------+-------------+-----------+
0 (3, 3, 1) [] (3, 3, 1)
1 (19, 22, 7) [6] (1, 4, 1)
2 (1843, 2130, 678) [96, 6] (1, 0, 0)
3 (51892, 59973, 19090) [28, 15, 1] (0, 0, 0)
4 (113018, 130618, 41577) [2, 5, 1] (0, 0, 0)
5 (114861, 132748, 42255) [1, 0, 1] (0, 0, 0)
6 (166753, 192721, 61345) [1, 0, 1] (0, 0, 0)
7 (446524, 516060, 164267) [2, 0, 1] (0, 0, 0)
But not in this case::
sage: dirichlet_convergents_dependance([pi,sqrt(3)], 12)
i vi lin. rec. remainder
+----+-----------------------+--------------------------+-----------+
0 (3, 2, 1) [] (3, 2, 1)
1 (22, 12, 7) [6] (4, 0, 1)
2 (47, 26, 15) [2, 1] (0, 0, 0)
3 (69, 38, 22) [1, 1] (0, 0, 0)
4 (176, 97, 56) [2, 0, 1, 4] (4, 1, 1)
5 (223, 123, 71) [1, 0, 1] (0, 0, 0)
6 (399, 220, 127) [1, 1] (0, 0, 0)
7 (1442, 795, 459) [3, 1, 0, 0, 0, 1] (0, 0, 0)
8 (6390, 3523, 2034) [4, 1, 1] (0, 0, 0)
9 (26603, 14667, 8468) [4, 0, 2, 1, 0, 0, 0, 1] (0, 0, 0)
10 (32993, 18190, 10502) [1, 1] (0, 0, 0)
11 (40825, 22508, 12995) [1, 0, 1, 1] (0, 0, 0)
The v4 is not a lin. comb. of the previous four::
sage: dirichlet_convergents_dependance([e,pi,sqrt(3)], 5)
i vi lin. rec. remainder
+---+---------------------------------+----------------+--------------+
0 (3, 3, 2, 1) [] (3, 3, 2, 1)
1 (19, 22, 12, 7) [6] (1, 4, 0, 1)
2 (193, 223, 123, 71) [10, 1] (0, 0, 1, 0)
3 (5529, 6390, 3523, 2034) [28, 6, 3] (2, 5, 1, 1)
4 (163067, 188461, 103904, 59989) [29, 14, 1, 1] (2, 4, 1, 1)
"""
L = []
it = best_simultaneous_convergents(v)
rows = []
for i in range(n):
vi = vector(next(it))
t = vi
M = []
for u in reversed(L):
m = floor(min(a / b for a, b in zip(t, u)))
M.append(m)
t -= m * u
if t == 0:
if verbose:
c = ','.join("v{}".format(len(L) - j)
for j in range(len(M)))
print "v{} = {} = <{}>.<{}>".format(i, vi, M, c)
break
else:
if verbose:
print "v{} = {} = <{}>.<v{}, ..., v0> + {}".format(
i, vi, M, i - 1, t)
L.append(vi)
row = [i, vi, M, t]
rows.append(row)
header_row = ['i', 'vi', 'lin. rec.', 'remainder']
from sage.misc.table import table
return table(rows=rows, header_row=header_row)
