def load_mangled(cls, name, dir=None):
r"""
Load an object based on its standardized name.
INPUT:
- ``cls`` -- the class object.
- ``name`` -- string: the file name suffix (without ".obj")
part of the standardized name.
- ``dir`` -- string, optional. The directory where the object
was saved. Default is None, meaning the current directory.
OUTPUT:
The object that was saved in the file referred to by the
standardized name and the directory.
EXAMPLES:
::
sage: import os
sage: from boolean_cayley_graphs.boolean_function_improved import BooleanFunctionImproved as BFI
sage: a = BFI([0,1,0,0])
sage: d = tmp_dir()
sage: a.save_mangled("a", dir=d)
sage: b = BFI.load_mangled("a", dir=d)
sage: a == b
True
sage: BFI.remove_mangled("a", dir=d)
sage: os.rmdir(d)
"""
return cls(load(cls.mangled_name(name, dir=dir)))
def zeta_zeros():
r"""
List of the imaginary parts of the first 2,001,052 zeros of the
Riemann zeta function, accurate to within 4e-9.
In order to use ``zeta_zeros()``, you will need to
install the optional Odlyzko database package::
sage -i database_odlyzko_zeta
You can see a list of all available optional packages with
``sage --optional``.
REFERENCES:
- http://www.dtc.umn.edu/~odlyzko/zeta_tables/index.html
EXAMPLES:
The following example prints the imaginary part of the 13th
nontrivial zero of the Riemann zeta function::
sage: zz = zeta_zeros() # optional - database_odlyzko_zeta
sage: zz[12] # optional - database_odlyzko_zeta
59.347044003
sage: len(zz) # optional - database_odlyzko_zeta
2001052
"""
from sage.misc.verbose import verbose
sobj = os.path.join(SAGE_SHARE, 'odlyzko', 'zeros.sobj')
verbose("Loading Odlyzko database from " + sobj)
return load(sobj)
def demo_version(self):
r"""
Return whether the KnotInfo databases are installed completely or
just the demo version is used.
EXAMPLES::
sage: from sage.databases.knotinfo_db import KnotInfoDataBase
sage: ki_db = KnotInfoDataBase()
sage: ki_db.demo_version() # optional - database_knotinfo
False
"""
if self._demo is None:
if self._feature.is_present():
num_knots_file = os.path.join(
self._sobj_path,
self.filename.knots.num_knots(self.version()))
from builtins import FileNotFoundError
try:
self._num_knots = load(num_knots_file)
except FileNotFoundError:
self.create_filecache()
self._demo = False
else:
self._demo = True
self._num_knots = len(
[v for v in row_demo_sample.values() if v[1] == 1])
return self._demo
def dict(self):
"""
Return the already computed values
"""
import glob
return dict(
persist.load(name)
for name in glob.glob("%s*.sobj" % self._prefix))
def _sage_(self):
"""
Return local copy of self.
EXAMPLES::
sage: sr = mq.SR(allow_zero_inversions=True)
sage: F,s = sr.polynomial_system()
sage: F == sage0(F)._sage_()
True
"""
P = self.parent()
if P.is_remote():
P.eval('save({}, {!r})'.format(self.name(), P._remote_tmpfile()))
P._get_tmpfile_from_server(self)
return load(P._local_tmp_file())
else:
P.eval('save({}, {!r})'.format(self.name(), P._local_tmpfile()))
return load(P._local_tmpfile())
def cunningham_prime_factors():
r"""
List of all the prime numbers occuring in the so called Cunningham table.
They occur in the factorization of numbers of type $b^n+1$ or $b^n-1$ with $b \in \{2,3,5,6,7,10,11,12\}$.
Data from http://cage.ugent.be/~jdemeyer/cunningham/
"""
file = os.path.join(SAGE_SHARE,'cunningham_tables','cunningham_prime_factors.sobj')
if os.path.exists(file):
return [Integer(_) for _ in load(file)]
else:
from warnings import warn
warn("You might consider installing the optional package for factoring Cunningham numbers with the following command: ``sage -i cunningham_tables``")
return []
def __call__(self, *args, **kwds):
key = self.key(*args, **kwds)
h = self._hash(key)
name = '%s_%s.sobj' % (self._prefix, h)
if os.path.exists(name):
key2, val = persist.load(name)
if key == key2:
# We save and test equality of keys to avoid
# the (extremely remote) possibility of a hash
# collision. Correctness is crucial in mathematics.
return val
val = self._func(*args, **kwds)
persist.save((key, val), name)
return val
def cunningham_prime_factors():
r"""
List of all the prime numbers occurring in the so called Cunningham table.
They occur in the factorization of numbers of type $b^n+1$ or $b^n-1$ with $b \in \{2,3,5,6,7,10,11,12\}$.
Data from http://cage.ugent.be/~jdemeyer/cunningham/
"""
file = os.path.join(SAGE_SHARE, 'cunningham_tables',
'cunningham_prime_factors.sobj')
if os.path.exists(file):
return [Integer(_) for _ in load(file)]
else:
from warnings import warn
warn(
"You might consider installing the optional package for factoring Cunningham numbers with the following command: ``sage -i cunningham_tables``"
)
return []
def read_column_dict(self):
r"""
Read the dictionary for the column names from the according sobj-file
OUTPUT:
A python dictionary containing the column names and types
EXAMPLES::
sage: from sage.databases.knotinfo_db import KnotInfoDataBase
sage: ki_db = KnotInfoDataBase()
sage: len(ki_db.read_column_dict()) > 120 # optional - database_knotinfo
True
"""
if self.demo_version():
return column_demo_sample
sobj_path = self._sobj_path
filename = self.filename.knots.sobj_column()
return load('%s/%s' % (sobj_path, filename))
def get(self, S, var='a'):
"""
Return all fields in the database ramified exactly at
the primes in S.
INPUT:
- ``S`` - list or set of primes, or a single prime
- ``var`` - the name used for the generator of the number fields (default 'a').
EXAMPLES::
sage: J = JonesDatabase() # optional - database_jones_numfield
sage: J.get(163, var='z') # optional - database_jones_numfield
[Number Field in z with defining polynomial x^2 + 163,
Number Field in z with defining polynomial x^3 - x^2 - 54*x + 169,
Number Field in z with defining polynomial x^4 - x^3 - 7*x^2 + 2*x + 9]
sage: J.get([3, 4]) # optional - database_jones_numfield
Traceback (most recent call last):
...
ValueError: S must be a list of primes
"""
if self.root is None:
if os.path.exists(JONESDATA + "/jones.sobj"):
self.root = load(JONESDATA + "/jones.sobj")
else:
raise PackageNotFoundError("database_jones_numfield")
try:
S = list(S)
except TypeError:
S = [S]
if not all(p.is_prime() for p in S):
raise ValueError("S must be a list of primes")
S.sort()
s = tuple(S)
if s not in self.root:
return []
return [NumberField(f, var, check=False) for f in self.root[s]]
def get(self, S, var='a'):
"""
Return all fields in the database ramified exactly at
the primes in S.
INPUT:
- ``S`` - list or set of primes, or a single prime
- ``var`` - the name used for the generator of the number fields (default 'a').
EXAMPLES::
sage: J = JonesDatabase() # optional - database_jones_numfield
sage: J.get(163, var='z') # optional - database_jones_numfield
[Number Field in z with defining polynomial x^2 + 163,
Number Field in z with defining polynomial x^3 - x^2 - 54*x + 169,
Number Field in z with defining polynomial x^4 - x^3 - 7*x^2 + 2*x + 9]
sage: J.get([3, 4]) # optional - database_jones_numfield
Traceback (most recent call last):
...
ValueError: S must be a list of primes
"""
if self.root is None:
if os.path.exists(JONESDATA + "/jones.sobj"):
self.root = load(JONESDATA + "/jones.sobj")
else:
raise PackageNotFoundError("database_jones_numfield")
try:
S = list(S)
except TypeError:
S = [S]
if not all([p.is_prime() for p in S]):
raise ValueError("S must be a list of primes")
S.sort()
s = tuple(S)
if s not in self.root:
return []
return [NumberField(f, var, check=False) for f in self.root[s]]
def read_row_dict(self):
r"""
Read the dictionary for the row names that is the knot and link names
from the according sobj-file
OUTPUT:
A python dictionary containing the names of the knots and links
together with their table index and the corresponding number of
components
EXAMPLES::
sage: from sage.databases.knotinfo_db import KnotInfoDataBase
sage: ki_db = KnotInfoDataBase()
sage: ki_db.read_row_dict()['K7_1']
[8, 1]
"""
if self.demo_version():
return row_demo_sample
sobj_path = self._sobj_path
filename = self.filename.knots.sobj_row()
return load('%s/%s' % (sobj_path, filename))
def read(self, column):
r"""
Access a column of KnotInfo / LinkInfo
INPUT:
``column`` -- instance of enum :class:`KnotInfoColumns`
to select the data to be read in
OUTPUT:
A python list containing the data corresponding to the column.
EXAMPLES::
sage: from sage.databases.knotinfo_db import KnotInfoDataBase
sage: ki_db = KnotInfoDataBase()
"""
if not isinstance(column, KnotInfoColumns):
raise TypeError('column must be an instance of enum %s' %
(KnotInfoColumns))
if self.demo_version():
return data_demo_sample[column]
sobj_path = self._sobj_path
if column.column_type() == column.types.OnlyLinks:
filename = self.filename.links.sobj_data(column)
else:
filename = self.filename.knots.sobj_data(column)
verbose('loading data library %s ...' % (filename))
res = load('%s/%s' % (sobj_path, filename))
verbose('... finished!')
return res
from sage.misc.misc_c import prod
from sage.misc.persist import load
from sage.modular.hypergeometric_motive import enumerate_hypergeometric_data, HypergeometricData
from sage.modules.free_module_element import vector
from sage.rings.fast_arith import prime_range
from sage.rings.finite_rings.finite_field_constructor import FiniteField as GF
from sage.rings.integer_ring import ZZ
from sage.rings.rational_field import QQ
# for pyflakes
def mbound_dict_c(indices, start, end):
pass
load(path.join(path.dirname(path.abspath(__file__)), "hgm_misc.pyx"))
# for pyflakes
def remainder_forest(M,
m,
k,
kbase=0,
indices=None,
V=None,
ans=None,
kappa=None):
pass
load(path.join(path.dirname(path.abspath(__file__)), "average_poly.pyx"))
def _create_data_sobj(self, sobj_path=None):
r"""
Create ``sobj`` files containing the contents of the whole table.
To each column there is created one file containing a list of
strings giving the entries of the database table.
The length of these lists depends on the type of the corresponding
column. If a column is used in both tables
(``KnotInfoColumnTypes.KnotsAndLinks``) the list of proper links
is appended to the list of knots. In both other cases the lenght
of the list corresponds to the number of listed knots and proper
links respectively.
EXAMPLES::
sage: from sage.databases.knotinfo_db import KnotInfoDataBase
sage: ki_db = KnotInfoDataBase()
sage: ki_db._create_data_sobj() # not tested (just used on installation)
"""
knot_list = self.knot_list()
link_list = self.link_list()
len_knots = len(knot_list)
len_links = len(link_list)
row_dict = {}
if not sobj_path:
sobj_path = self._sobj_path
# ----------------------------------------------------------------
# Columns that exist for knots and links
# ----------------------------------------------------------------
column_dict = load('%s/%s' %
(sobj_path, self.filename.knots.sobj_column()))
cols = KnotInfoColumns('ColsTemp', column_dict)
for col in cols:
val_list = []
if col.column_type() != col.types.OnlyLinks:
for i in range(1, len_knots):
if col.name == self._names_column:
row_dict[self._knot_prefix +
knot_list[i][col.name]] = [i - 1, 1]
val_list.append(knot_list[i][col.name])
if col.column_type() != col.types.OnlyKnots:
for i in range(1, len_links):
if col.name == self._names_column:
link_name = link_list[i][col.name]
link_name = link_name.replace('{', '_')
link_name = link_name.replace(',', '_')
link_name = link_name.replace('}', '')
num_comp = int(link_list[i][self._components_column])
row_dict[link_name] = [i + len_knots - 2, num_comp]
val_list.append(link_list[i][col.name])
if val_list:
save(val_list,
'%s/%s' % (sobj_path, self.filename.knots.sobj_data(col)))
save(row_dict, '%s/%s' % (sobj_path, self.filename.knots.sobj_row()))
