def coefficients(self, nrange=range(1, 10), save_to_db=False): r""" Gives the coefficients in a range. We assume that the self._ap containing Hecke eigenvalues are stored. """ if len(nrange) == 0: return [] if not isinstance(nrange, list): M = nrange nrange = range(0, M) if len(nrange) > 1: emf_logger.debug("getting coeffs in range {0}--{1}".format(nrange[0],nrange[-1])) else: emf_logger.debug("getting coeffs in range {0}--{0}".format(nrange[0])) res = [] recompute = False for n in nrange: c = self._coefficients.get(n, None) #emf_logger.debug("c({0}) in self._coefficients={1}".format(n,c)) if c is None: if n == 0 and self.is_cuspidal: c = 0 else: recompute = True c = self.coefficient_n_recursive(n) self._coefficients[n] = c res.append(c) if recompute and save_to_db: self.save_to_db(update=True) return res
def get_coefficients(info): r""" Return a file with the Fourier coefficients in desired format. """ emf_logger.debug("IN GET_COEFFICIENTS!!!") level = my_get(info, 'level', -1, int) weight = my_get(info, 'weight', -1, int) character = my_get(info, 'character', '', str) # int(info.get('weight',0)) emf_logger.debug("info={0}".format(info)) if character == '': character = 0 label = info.get('label', '') # we only want one form or one embedding s = print_list_of_coefficients(info) print "s=",s if info['format']=="sage": ending = "sobj" else: ending = "txt" info['filename'] = str(weight) + '-' + str( level) + '-' + str(character) + '-' + label + 'coefficients-0to' + info['number'] + "."+ending # return send_file(info['tempfile'], as_attachment=True, attachment_filename=info['filename']) strIO = StringIO.StringIO() strIO.write(s) strIO.seek(0) return send_file(strIO, attachment_filename=info["filename"], as_attachment=True)
def render_elliptic_modular_form_space_list_chars(level, weight): r""" Renders a page with list of spaces of elliptic forms of given level and weight (list all characters) """ emf_logger.debug( "In render_elliptic_modular_form_space_list_chars(level={0},weight={1})".format(level, weight)) info = dict() # s = make_table_of_characters(level,weight) info['level'] = level info['weight'] = weight # if not isinstance(s,str): # info['character'] = s # return redirect(url_for("emf.render_elliptic_modular_forms", **info)) # info['list_spaces']=s title = "Newforms of weight {0} for \(\Gamma_1({1})\)".format(weight, level) # bread =[(MF_TOP,url_for('mf.modular_form_main_page'))] bread = [(EMF_TOP, url_for('emf.render_elliptic_modular_forms'))] bread.append(("Level %s" % level, url_for("emf.render_elliptic_modular_forms", level=level))) bread.append( ("Weight %s" % weight, url_for("emf.render_elliptic_modular_forms", level=level, weight=weight))) # info['browse_type']=" of level %s and weight %s " % (level,weight) dimtbl = DimensionTable(1) info['grouptype'] = 1 disp = ClassicalMFDisplay('modularforms') disp.set_table_browsing(limit=[(weight, weight), (level, level)], keys=['Weight', 'Level'], character='all', dimension_table=dimtbl, title='Dimension of newforms') info['show_all_characters'] = 1 info['browse_table'] = disp._table info['bread'] = bread info['title'] = title return render_template("emf_browse_fixed_level.html", **info)
def get_coefficients(info): r""" Return a file with the Fourier coefficients in desired format. """ emf_logger.debug("IN GET_COEFFICIENTS!!!") level = my_get(info, 'level', -1, int) weight = my_get(info, 'weight', -1, int) character = my_get(info, 'character', '', str) # int(info.get('weight',0)) emf_logger.debug("info={0}".format(info)) if character == '': character = 0 label = info.get('label', '') # we only want one form or one embedding s = print_list_of_coefficients(info) print "s=", s if info['format'] == "sage": ending = "sobj" else: ending = "txt" info['filename'] = str(weight) + '-' + str(level) + '-' + str( character ) + '-' + label + 'coefficients-0to' + info['number'] + "." + ending # return send_file(info['tempfile'], as_attachment=True, attachment_filename=info['filename']) strIO = StringIO.StringIO() strIO.write(s) strIO.seek(0) return send_file(strIO, attachment_filename=info["filename"], as_attachment=True)
def return_dimension(level=None, weight=None, chi=None, **kwds): if request.method == 'GET': info = to_dict(request.args) else: info = to_dict(request.form) level = my_get(info, 'level', level, int) weight = my_get(info, 'weight', weight, int) chi = my_get(info, 'chi', chi, int) if level is None or weight is None: return emf_error("Please supply level weight (and optional character)!"), 500 ttype = my_get(kwds, 'ttype', info.get('ttype', 'new'), str) emf_logger.debug("level,weight,chi: {0},{1},{2}, type={3}".format(level, weight, chi, ttype)) if chi == 0 or chi is None: x = level else: x = DirichletGroup(level).list()[chi] if ttype == 'new': return str(dimension_new_cusp_forms(x, weight)) if ttype == 'cusp': return str(dimension_cusp_forms(x, weight)) if ttype == 'modular': return str(dimension_modular_forms(x, weight)) if ttype == 'eisenstein': return str(dimension_eis(x, weight)) s = "Please use one of the available table types: 'new', 'cusp','modular', 'eisenstein' Got:{0}".format( ttype) return emf_error(s), 500
def get_new_and_oldspace_decomposition(k, N, xi=0): r""" Get decomposition of the new and oldspace S_k(N,xi) into submodules. """ M = ModularSymbols(N, k, sign=1).cuspidal_submodule() L = list() L = [M.new_submodule().dimension()] check_dim = M.new_submodule().dimension() for d in divisors(N): if (d == 1): continue O = M.old_submodule(d) Od = O.dimension() if (d == N and k == 2 or Od == 0): continue S = ModularSymbols(ZZ(N / d), k, sign=1).cuspidal_submodule().new_submodule() Sd = S.dimension() if (Sd == 0): logger.debug("%s, %s" % (O, Od)) logger.debug("%s, %s" % (S, Sd)) mult = len(divisors(ZZ(d))) check_dim = check_dim + mult * Sd L.append((ZZ(N / d), mult, Sd)) check_dim = check_dim - M.dimension() if (check_dim != 0): raise ArithmeticError("Something wrong! check_dim=%s" % check_dim) return str(M.dimension(), L)
def compute(self, save=True): emf_logger.debug('in compute for WebChar number {0} of modulus {1}'.format(self.number, self.modulus)) c = self.character changed = False if self.conductor == 0: self.conductor = c.conductor() changed = True if self.order == 0: self.order = c.multiplicative_order() changed = True if self.latex_name == '': self.latex_name = "\chi_{" + str(self.modulus) + "}(" + str(self.number) + ", \cdot)" changed = True if self._values_algebraic == {} or self._values_float == {}: changed = True for i in range(self.modulus): self.value(i,value_format='float') self.value(i,value_format='algebraic') if self.modulus_euler_phi == 0: changed = True self.modulus_euler_phi = euler_phi(self.modulus) if changed and save and False: # temporary hack to prevent fatal error when save_to_db fails self.save_to_db() else: emf_logger.debug('Not saving.')
def __init__(self, name, level=1, weight=12, character=1, value=None, update_hecke_orbits=False, include_in_update=False): self.level = level self.weight = weight self.character = character emf_logger.debug("CCCCharacter = {0}".format(self.character)) if value is None: value = WebModFormSpace_cached( self.level, self.weight, self.character, update_hecke_orbits=update_hecke_orbits) emf_logger.debug("CCCCharacter = {0}".format(self.character)) super(WebModFormSpaceProperty, self).__init__(name, include_in_update=include_in_update, save_to_db=True, save_to_fs=False, value=value)
def extract_data_from_jump_to(s): label = '' args = dict() if s == 'delta': weight = 12 level = 1 label = "a" else: # first see if we have a label or not, i.e. if we have precisely one string of letters at the end test = re.findall("[a-z]+", s) if len(test) == 1: args['label'] = test[0] # emf_logger.debug("label1={0}".format(label)) # the first string of integers should be the level test = re.findall("\d+", s) if not test is None and len(test)>0: args['level'] = int(test[0]) if len(test) > 1: # we also have weight args['weight'] = int(test[1]) if len(test) > 2: # we also have character args['character']=int(test[2]) emf_logger.debug("args=%s" % label) return args
def print_coefficients_for_one_form(F, number, fmt, bitprec=53): emf_logger.debug( "in print {2} coefs for 1 form: format={0} bitprec={1}".format( fmt, bitprec, number)) # Start with some meta-data s = "## level={N}, weight={k}, character={ch},label={label} \n".format( N=F.level(), k=F.weight(), ch=F.chi(), label=F.label()) max_cn = F.max_cn() if number > max_cn: number = max_cn if fmt == "q_expansion": s += F.print_q_expansion(number) if fmt == "coefficients": qe = F.coefficients(range(number)) if F.degree() > 1: s += "## " + str(F.polynomial(type='coefficient_field')) + "=0" s += "\n" for n in range(len(qe)): c = qe[n] s += "{n} \t {c} \n".format(n=n, c=c) if fmt == "embeddings": embeddings = F.q_expansion_embeddings(number, bitprec=bitprec, format='numeric') if F.degree() > 1: for j in range(F.degree()): s += "# Embedding nr. {j} \n".format(j=j) for n in range(number): s += str(n) + "\t" + str(embeddings[n][j]) + "\n" else: for n in range(number): s += str(n) + "\t" + str(embeddings[n]) + "\n" emf_logger.debug("s={0}".format(s)) return s
def coefficients(self, nrange=range(1, 10), save_to_db=True): r""" Gives the coefficients in a range. We assume that the self._ap containing Hecke eigenvalues are stored. """ emf_logger.debug("computing coeffs in range {0}".format(nrange)) if not isinstance(nrange, list): M = nrange nrange = range(0, M) res = [] recompute = False for n in nrange: c = self._coefficients.get(n, None) #emf_logger.debug("c({0}) in self._coefficients={1}".format(n,c)) if c is None: if n == 0 and self.is_cuspidal: c = self.coefficient_field(0) else: recompute = True c = self.coefficient_n_recursive(n) self._coefficients[n] = c res.append(c) if recompute and save_to_db: self.save_to_db(update=True) return res
def compute(self, save=True): emf_logger.debug( 'in compute for WebChar number {0} of modulus {1}'.format( self.number, self.modulus)) c = self.character changed = False if self.conductor == 0: self.conductor = c.conductor() changed = True if self.order == 0: self.order = c.multiplicative_order() changed = True if self.latex_name == '': self.latex_name = "\chi_{" + str(self.modulus) + "}(" + str( self.number) + ", \cdot)" changed = True if self._values_algebraic == {} or self._values_float == {}: changed = True for i in range(self.modulus): self.value(i, value_format='float') self.value(i, value_format='algebraic') if self.modulus_euler_phi == 0: changed = True self.modulus_euler_phi = euler_phi(self.modulus) if changed and save: self.save_to_db() else: emf_logger.debug('Not saving.')
def render_web_modform_space_gamma1(level=None, weight=None, character=None, label=None, **kwds): r""" Render the webpage for the space of elliptic modular forms on gamma1 as a table of spaces of spaces on gamma0 with associated characters. """ emf_logger.debug( "In render_ellitpic_modular_form_space kwds: {0}".format(kwds)) emf_logger.debug( "Input: level={0},weight={1},character={2},label={3}".format( level, weight, character, label)) info = to_dict(kwds) info['level'] = level info['weight'] = weight info['character'] = character title = "Newforms of weight {0} for \(\Gamma_1({1})\)".format( weight, level) bread = [(EMF_TOP, url_for('emf.render_elliptic_modular_forms'))] bread.append(("Level %s" % level, url_for("emf.render_elliptic_modular_forms", level=level))) bread.append(("Weight %s" % weight, url_for("emf.render_elliptic_modular_forms", level=level, weight=weight))) info['grouptype'] = 1 info['show_all_characters'] = 1 info['table'] = set_info_for_gamma1(level, weight) info['bread'] = bread info['title'] = title info['showGaloisOrbits'] = 1 return render_template("emf_render_web_modform_space_gamma1.html", **info)
def get_downloads(level=None, weight=None, character=None, label=None, **kwds): keys = ['download', 'download_file', 'tempfile', 'format', 'number','bitprec'] info = get_args(request, level, weight, character, label, keys=keys) # info = to_dict(request.form) # info['level']=level; info['weight']=weight; info['character']=character; info['label']=label if 'download' not in info: emf_logger.critical("Download called without specifying what to download!") return "" emf_logger.debug("in get_downloads: info={0}".format(info)) if info['download'] == 'file': # there are only a certain number of fixed files that we want people to download filename = info['download_file'] if filename == "web_modforms.py": dirname = emf.app.root_static_folder try: emf_logger.debug("Dirname:{0}, Filename:{1}".format(dirname, filename)) return send_from_directory(dirname, filename, as_attachment=True, attachment_filename=filename) except IOError: info['error'] = "Could not find file! " if info['download'] == 'coefficients': info['tempfile'] = "/tmp/tmp_web_mod_form.txt" return get_coefficients(info) if info['download'] == 'object': return download_web_modform(info) info['error'] = "Could not find file! "
def dimension_gamma1(self, arg1, k=3): if self._table is None: return "n/a" if type(arg1) == sage.modular.dirichlet.DirichletCharacter: N = arg1.modulus() character = arg1.parent().galois_orbits().index(arg1.galois_orbit()) else: if type(arg1) == int or type(arg1) == Integer: N = arg1 character = -1 else: return -1 emf_logger.debug( 'Lookup dimension for Gamma1({0}), weight={1}, character={2}'.format(N, k, character)) if N in self._table.keys(): # emf_logger.debug('Have information for level {0}'.format(N)) tblN = self._table[N] if k in tblN.keys() and character in tblN[k].keys(): # emf_logger.debug('Lookup dimension for Gamma1({0}), weight={1}, # character={2}'.format(N,k,character)) dim = tblN[k][character]['dimension'] # emf_logger.debug('Have dimension for Gamma1({0}), weight={1}, # character={1}'.format(N,k,character)) return dim return "n/a"
def print_coefficients_for_one_form(F, number, fmt,bitprec=53): emf_logger.debug("in print {2} coefs for 1 form: format={0} bitprec={1}".format(fmt,bitprec,number)) # Start with some meta-data s = "## level={N}, weight={k}, character={ch},label={label} \n".format(N=F.level(),k=F.weight(),ch=F.chi(),label=F.label()) max_cn = F.max_cn() if number > max_cn: number = max_cn if fmt == "q_expansion": s += F.print_q_expansion(number) if fmt == "coefficients": qe = F.coefficients(range(number)) if F.degree() > 1: s += "## "+str(F.polynomial(type='coefficient_field'))+"=0" s += "\n" for n in range(len(qe)): c=qe[n] s += "{n} \t {c} \n".format(n=n,c=c) if fmt == "embeddings": embeddings = F.q_expansion_embeddings(number,bitprec=bitprec,format='numeric') if F.degree() > 1: for j in range(F.degree()): s+="# Embedding nr. {j} \n".format(j=j) for n in range(number): s += str(n) + "\t" + str(embeddings[n][j]) + "\n" else: for n in range(number): s += str(n) + "\t" + str(embeddings[n]) + "\n" emf_logger.debug("s={0}".format(s)) return s
def extract_limits_as_tuple(arg, field): fld = arg.get(field) try: if isinstance(fld,basestring): tmp = parse_range(fld, use_dollar_vars=False) if isinstance(tmp,dict): limits = (tmp['min'],tmp['max']) else: limits = (tmp,tmp) elif isinstance(fld,(tuple,list)): limits = (int(fld[0]),int(fld[1])) elif isinstance(fld,dict): limits = (fld['min'], fld['max']) elif not fld is None: limits = (fld,fld) else: limits = None except (TypeError,ValueError) as e: emf_logger.debug("Error in search parameters. {0} ".format(e)) msg = safe_non_valid_input_error(arg.get(field),field) if field == 'label': msg += " Need a label which is a sequence of letters, for instance 'a' or 'ab' for input" else: msg += " Need either a positive integer or a range of positive integers as input." flash(msg,"error") return None return limits
def extract_limits_as_tuple(arg, field): fld = arg.get(field) try: if isinstance(fld, basestring): tmp = parse_range(fld, use_dollar_vars=False) if isinstance(tmp, dict): limits = (tmp['min'], tmp['max']) else: limits = (tmp, tmp) elif isinstance(fld, (tuple, list)): limits = (int(fld[0]), int(fld[1])) elif isinstance(fld, dict): limits = (fld['min'], fld['max']) elif not fld is None: limits = (fld, fld) else: limits = None except (TypeError, ValueError) as e: emf_logger.debug("Error in search parameters. {0} ".format(e)) msg = safe_non_valid_input_error(arg.get(field), field) if field == 'label': msg += " Need a label which is a sequence of letters, for instance 'a' or 'ab' for input" else: msg += " Need either a positive integer or a range of positive integers as input." flash(msg, "error") return None return limits
def init_dynamic_properties(self, embeddings=False): if self.number is not None: emf_logger.debug('number: {0}'.format(self.number)) self.character = DirichletCharacter_conrey( DirichletGroup_conrey(self.modulus), self.number) if not self.number == 1: self.sage_character = self.character.sage_character() else: self.sage_character = trivial_character(self.modulus) self.name = "Character nr. {0} of modulus {1}".format( self.number, self.modulus) if embeddings: from lmfdb.modular_forms.elliptic_modular_forms.backend.emf_utils import dirichlet_character_conrey_galois_orbit_embeddings emb = dirichlet_character_conrey_galois_orbit_embeddings( self.modulus, self.number) self.set_embeddings(emb) c = self.character if self.conductor == 0: self.conductor = c.conductor() if self.order == 0: self.order = c.multiplicative_order() if self.modulus_euler_phi == 0: self.modulus_euler_phi = euler_phi(self.modulus) if self.latex_name == '': self.latex_name = "\chi_{" + str(self.modulus) + "}(" + str( self.number) + ", \cdot)"
def download_to_sage(self, prec=None): r""" Minimal version for now to download to sage. Does not work for high values of prec for large degree number fields (timeout). """ if prec is None: prec = self.prec s = "var('x')\n" if self.base_ring.absolute_degree() > 1: s += "K.<brgen>=NumberField(crpol)\n".format(brgen=str(self.base_ring.gen()), crpol=self.base_ring.polynomial()) if self.coefficient_field.absolute_degree() > 1: s += "L.<{cfgen}> = NumberField({cfpol})\n".format( cfgen=str(self.coefficient_field.gen()), cfpol=self.absolute_polynomial ) s = s + "D = DirichletGroup({N})\n".format( N = self.level ) C = self.character.sage_character.parent() if C.zeta_order()>2: s = s + "{Dzeta}=CyclotomicField({Dzord}).gen()\n".format(Dzord=C.zeta_order(), Dzeta = C.zeta()) s = s + "f = {{'coefficients': {coeffs}, 'level' : {level}, 'weight': {weight}, 'character': D.Element(D,{vog}), 'label': '{label}','dimension': {dim}, 'is_cm': {cm} , 'cm_discriminant': {cm_disc}, 'atkin_lehner': {al}, 'explicit_formulas': {ep}}}".format(coeffs = self.coefficients(range(prec)), level=self.level, weight=self.weight, vog = self.character.sage_character.values_on_gens(), label=self.hecke_orbit_label, dim=self.dimension, cm=self.is_cm, cm_disc=None if not self.is_cm else self.cm_disc , al=self.atkin_lehner_eigenvalues(), ep = self.explicit_formulas ) s = s + "\n\n#EXAMPLE\n" s = s + "#sage: f['coefficients'][7]\n#{}\n".format(self.coefficient(7)) s = s + "#sage: f['character']\n#{}".format(self.character.sage_character) emf_logger.debug("Generated sage file for {}".format(self.hecke_orbit_label)) return s
def compute(self, save=True): emf_logger.debug("in compute for WebChar number {0} of modulus {1}".format(self.number, self.modulus)) c = self.character changed = False if self.conductor == 0: self.conductor = c.conductor() changed = True if self.order == 0: self.order = c.multiplicative_order() changed = True if self.latex_name == "": self.latex_name = "\chi_{" + str(self.modulus) + "}(" + str(self.number) + ", \cdot)" changed = True if self._values_algebraic == {} or self._values_float == {}: changed = True for i in range(self.modulus): self.value(i, value_format="float") self.value(i, value_format="algebraic") if self.modulus_euler_phi == 0: changed = True self.modulus_euler_phi = euler_phi(self.modulus) if changed and save: self.save_to_db() else: emf_logger.debug("Not saving.")
def __init__(self, dbname='', **kwds): emf_logger.debug("in ClassicalMFDisplay kwds={0}".format(kwds)) MFDisplay.__init__(self, dbname, **kwds) import lmfdb.base Conn = lmfdb.base.getDBConnection() #if dbname == '': dbname = 'modularforms2'
def create_small_record(self, min_prec=10, want_prec=100, max_length = 5242880, max_height_qexp = default_max_height): ### creates a duplicate record (fs) of this webnewform ### with lower precision to load faster on the web ### we aim to have at most max_length bytes ### but at least min_prec coefficients and we desire to have want_prec if min_prec>=self.prec: raise ValueError("Need higher precision, self.prec = {}".format(self.prec)) if not hasattr(self, '_file_record_length'): self.update_from_db() l = self._file_record_length if l > max_length or self.prec > want_prec: nl = float(l)/float(self.prec)*float(want_prec) if nl > max_length: prec = max([floor(float(self.prec)/float(l)*float(max_length)), min_prec]) else: prec = want_prec emf_logger.debug("Creating a new record with prec = {}".format(prec)) self.prec = prec include_coeffs = self.complexity_of_first_nonvanishing_coefficients() <= default_max_height if include_coeffs: self.q_expansion = self.q_expansion.truncate_powerseries(prec) self._coefficients = {n:c for n,c in self._coefficients.iteritems() if n<prec} else: self.q_expansion = self.q_expansion.truncate_powerseries(1) self._coefficients = {} self.prec = 0 self.coefficient_field = NumberField(self.absolute_polynomial, names=str(self.coefficient_field.gen())) self._embeddings['values'] = {n:c for n,c in self._embeddings['values'].iteritems() if n<prec} self._embeddings['prec'] = prec self.save_to_db()
def save_to_db(self, update=True): r""" Saves ```self``` to the database, i.e. save the meta record and the file in the gridfs file system. """ fs = self._files file_key = self.file_key_dict() coll = self._file_collection if fs.exists(file_key): if not update: return True else: fid = coll.find_one(file_key, projection=['_id'])['_id'] fs.delete(fid) emf_logger.debug("Deleted file with fid={0}".format(fid)) # insert s = dumps(self.fs_dict()) if not self._use_separate_db: file_key.update(self.db_dict()) try: t = fs.put(s, **file_key) emf_logger.debug("Inserted file t={0}, filekey={1}".format( t, file_key)) except Exception, e: emf_logger.warn("Error inserting record: {0}".format(e))
def __init__(self, modulus=1, number=1, update_from_db=True, compute=False): r""" Init self. """ emf_logger.critical("In WebChar {0}".format((modulus, number, update_from_db, compute))) if not gcd(number, modulus) == 1: raise ValueError, "Character number {0} of modulus {1} does not exist!".format(number, modulus) if number > modulus: number = number % modulus self._properties = WebProperties( WebInt("conductor"), WebInt("modulus", value=modulus), WebInt("number", value=number), WebInt("modulus_euler_phi"), WebInt("order"), WebStr("latex_name"), WebStr("label", value="{0}.{1}".format(modulus, number)), WebNoStoreObject("sage_character", type(trivial_character(1))), WebDict("_values_algebraic"), WebDict("_values_float"), WebDict("_embeddings"), WebFloat("version", value=float(emf_version)), ) emf_logger.debug("Set properties in WebChar!") super(WebChar, self).__init__(update_from_db=update_from_db) if self._has_updated_from_db is False: self.init_dynamic_properties() # this was not done if we exited early compute = True if compute: self.compute(save=True) # emf_logger.debug('In WebChar, self.__dict__ = {0}'.format(self.__dict__)) emf_logger.debug("In WebChar, self.number = {0}".format(self.number))
def download_to_sage(self, prec=None): r""" Minimal version for now to download to sage. Does not work for high values of prec for large degree number fields (timeout). """ if prec is None: prec = self.prec s = "var('x')\n" if self.base_ring.absolute_degree() > 1: s += "K.<{brgen}>=NumberField({crpol})\n".format(brgen=str(self.base_ring.gen()), crpol=self.base_ring.polynomial().change_variable_name('x')) if self.coefficient_field.is_absolute(): if self.coefficient_field.absolute_degree() > 1: s += "L.<{cfgen}> = NumberField({cfpol})\n".format( cfgen=str(self.coefficient_field.gen()), cfpol=self.absolute_polynomial ) elif self.coefficient_field.relative_degree() > 1: s += "y = polygen(K)\n" s += "L.<{cfgen}> = NumberField({cfpol})\n".format( cfgen=str(self.coefficient_field.gen()), cfpol=self.coefficient_field.relative_polynomial().change_variable_name('y') ) s = s + "D = DirichletGroup({N})\n".format( N = self.level ) C = self.character.sage_character.parent() s = s + "f = {{'coefficients': {coeffs}, 'level' : {level}, 'weight': {weight}, 'character': D.Element(D,vector({elt})), 'label': '{label}','dimension': {dim}, 'is_cm': {cm} , 'cm_discriminant': {cm_disc}, 'atkin_lehner': {al}, 'explicit_formulas': {ep}}}".format(coeffs = self.coefficients(range(prec)), level=self.level, weight=self.weight, elt = list(self.character.sage_character.element()), label=self.hecke_orbit_label, dim=self.dimension, cm=self.is_cm, cm_disc=None if not self.is_cm else self.cm_disc , al=self.atkin_lehner_eigenvalues(), ep = self.explicit_formulas ) s = s + "\n\n#EXAMPLE\n" s = s + "#sage: f['coefficients'][7]\n#{}\n".format(self.coefficient(7)) s = s + "#sage: f['character']\n#{}".format(self.character.sage_character) emf_logger.debug("Generated sage file for {}".format(self.hecke_orbit_label)) return s
def convert(self): if len(self._value) == 0: return convert_to = self._convert_to #more types to come? if not convert_to in ['auto', 'poly', None]: raise NotImplementedError("convert to {} not Implemented".format(convert_to)) if convert_to is None: pass if self._elt_type is None: self.set_elt_type() if convert_to == 'auto': if self._elt_type == 'nfrel': convert_to = 'poly' if convert_to == 'poly': elt = self._value.values()[0] if self._elt_type == 'nfabs': emf_logger.debug("Converting from nfabs to poly!") R = PolynomialRing(QQ,names=str(elt.parent().gen())) self._value = {k: R(str(v)) for k,v in self._value.iteritems()} elif self._elt_type == 'nfrel': emf_logger.debug("Converting from nfrel to poly!") if elt.parent().base_ring() == QQ: R = QQ else: R = PolynomialRing(QQ,names=str(elt.parent().base_ring().gen())) T = PolynomialRing(R,names=str(elt.parent().gen())) #R = PolynomialRing(QQ, names=[str(self._value.values()[0].parent().base_ring().gen()),\ # str(self._value.values()[0].parent().gen())]) self._elt_type = 'poly' self._value = {k: T(str(v)) for k,v in self._value.iteritems()}
def print_list_of_coefficients(info): r""" Print a table of Fourier coefficients in the requested format """ level = my_get(info, 'level', -1, int) weight = my_get(info, 'weight', -1, int) prec = my_get(info, 'prec', 12, int) # number of digits bitprec = my_get(info, 'bitprec', 12, int) # number of digits character = my_get(info, 'character', '', str) # int(info.get('weight',0)) fmt = info.get("format", "q_expansion") if character == '': character = '1' label = info.get('label', '') if character.isalnum(): character = int(character) else: return "The character '{0}' is not well-defined!".format(character) print "--------------" if label == '' or level == -1 or weight == -1: return "Need to specify a modular form completely!!" number = int(info['number']) + 1 if 'number' in info else 20 emf_logger.debug("number = {}".format(number)) F = WebNewForm(level=level, weight=weight, character=character, label=label, prec=number) if not F.has_updated(): return "" if not 'number' in info: F.prec = number = max(F.parent.sturm_bound + 1, 20) F.update_from_db() shead = "Cusp forms of weight " + str(weight) + "on \(" + latex( F.parent.group) + "\)" s = "" if ((character is not None) and (character > 0)): shead = shead + " and character \( \chi_{" + str(character) + "}\)" # s="<table><tr><td>" coefs = "" if fmt == "sage": res = [] if number > F.max_available_prec(): raise IndexError, "The database does not contain this many ({0}) coefficients for this modular form! We only have {1}".format( number, F.max_available_prec()) if fmt == "sage": qe = F.coefficients(range(number)) res.append(qe) else: coefs += print_coefficients_for_one_form(F, number, info['format'], bitprec=bitprec) if not fmt == "sage": return s + "\n" + coefs else: if len(res) == 1: res = res[0] #print "res=",res return dumps(res)
def get_new_and_oldspace_decomposition(k, N, xi=0): r""" Get decomposition of the new and oldspace S_k(N,xi) into submodules. """ M = ModularSymbols(N, k, sign=1).cuspidal_submodule() L = list() L = [M.new_submodule().dimension()] check_dim = M.new_submodule().dimension() for d in divisors(N): if(d == 1): continue O = M.old_submodule(d) Od = O.dimension() if(d == N and k == 2 or Od == 0): continue S = ModularSymbols(ZZ(N / d), k, sign=1).cuspidal_submodule().new_submodule() Sd = S.dimension() if(Sd == 0): logger.debug("%s, %s" % (O, Od)) logger.debug("%s, %s" % (S, Sd)) mult = len(divisors(ZZ(d))) check_dim = check_dim + mult * Sd L.append((ZZ(N / d), mult, Sd)) check_dim = check_dim - M.dimension() if(check_dim != 0): raise ArithmeticError("Something wrong! check_dim=%s" % check_dim) return str(M.dimension(), L)
def extract_data_from_jump_to(s): label = '' weight = 0 character = 0 level = 1 if s == 'delta': weight = 12 level = 1 label = "a" else: # first see if we have a label or not, i.e. if we have precisely one string of letters at the end test = re.findall("[a-z]+", s) if len(test) == 1: label = test[0] # emf_logger.debug("label1={0}".format(label)) # the first string of integers should be the level test = re.findall("\d+", s) if not test is None and len(test)>0: level = int(test[0]) if len(test) > 1: # we also have weight weight = int(test[1]) if len(test) > 2: # we also have character character = int(test[2]) emf_logger.debug("label=%s" % label) emf_logger.debug("level=%s" % level) args = dict() args['level'] = int(level) args['weight'] = int(weight) args['character'] = int(character) if label: args['label'] = label return args
def dimension_gamma1(self, arg1, k=3): if self._table is None: return "n/a" if type(arg1) == sage.modular.dirichlet.DirichletCharacter: N = arg1.modulus() character = arg1.parent().galois_orbits().index( arg1.galois_orbit()) else: if type(arg1) == int or type(arg1) == Integer: N = arg1 character = -1 else: return -1 emf_logger.debug( 'Lookup dimension for Gamma1({0}), weight={1}, character={2}'. format(N, k, character)) if N in self._table.keys(): # emf_logger.debug('Have information for level {0}'.format(N)) tblN = self._table[N] if k in tblN.keys() and character in tblN[k].keys(): # emf_logger.debug('Lookup dimension for Gamma1({0}), weight={1}, # character={2}'.format(N,k,character)) dim = tblN[k][character]['dimension'] # emf_logger.debug('Have dimension for Gamma1({0}), weight={1}, # character={1}'.format(N,k,character)) return dim return "n/a"
def get_downloads(level=None, weight=None, character=None, label=None, **kwds): keys = [ 'download', 'download_file', 'tempfile', 'format', 'number', 'bitprec' ] info = get_args(request, level, weight, character, label, keys=keys) # info = to_dict(request.form) # info['level']=level; info['weight']=weight; info['character']=character; info['label']=label if 'download' not in info: emf_logger.critical( "Download called without specifying what to download!") return "" emf_logger.debug("in get_downloads: info={0}".format(info)) if info['download'] == 'file': # there are only a certain number of fixed files that we want people to download filename = info['download_file'] if filename == "web_modforms.py": dirname = emf.app.root_static_folder try: emf_logger.debug("Dirname:{0}, Filename:{1}".format( dirname, filename)) return send_from_directory(dirname, filename, as_attachment=True, attachment_filename=filename) except IOError: info['error'] = "Could not find file! " if info['download'] == 'coefficients': info['tempfile'] = "/tmp/tmp_web_mod_form.txt" return get_coefficients(info) if info['download'] == 'object': return download_web_modform(info) info['error'] = "Could not find file! "
def create_small_record(self, min_prec=10, want_prec=100, max_length = 5242880, max_height_qexp = default_max_height): ### creates a duplicate record (fs) of this webnewform ### with lower precision to load faster on the web ### we aim to have at most max_length bytes ### but at least min_prec coefficients and we desire to have want_prec if min_prec>=self.prec: raise ValueError("Need higher precision, self.prec = {}".format(self.prec)) l = self._file_record_length if l > max_length or self.prec > want_prec: nl = float(l)/float(self.prec)*float(want_prec) if nl > max_length: prec = max([floor(float(self.prec)/float(l)*float(max_length)), min_prec]) else: prec = want_prec emf_logger.debug("Creating a new record with prec = {}".format(prec)) self.prec=prec include_qexp = self.complexity_of_first_nonvanishing_coefficients() <= default_max_height if include_qexp: self.q_expansion = self.q_expansion.truncate_powerseries(prec) else: self.q_expansion = self.q_expansion.truncate_powerseries(1) self._coefficients = {n:c for n,c in self._coefficients.iteritems() if n<prec} self._embeddings['values'] = {n:c for n,c in self._embeddings['values'].iteritems() if n<prec} self._embeddings['prec'] = prec self.save_to_db()
def WebNewForm_cached(level,weight,character,label,parent=None, **kwds): if use_cache: M = WebModFormSpace_cached(level, weight, character, **kwds) return M.hecke_orbits[label] else: F = WebNewForm(level,weight,character,label,**kwds) emf_logger.debug("Computed F not using cache!") return F
def update_from_db(self, **kwargs): self._add_to_fs_query = {'prec': {'$gt': int(self.prec-1)}} self._sort = [('prec', pymongo.ASCENDING)] self._sort_files = [('prec', pymongo.ASCENDING)] emf_logger.debug(self._add_to_fs_query) super(WebEigenvalues,self).update_from_db(**kwargs) #remember the precision we got after updating for every query (not only update_from_db uses this) self._add_to_fs_query = {'prec': {'$gt': int(self.prec-1)}}
def update_from_db(self, **kwargs): self._add_to_fs_query = {'prec': {'$gt': int(self.prec-1)}} self._sort = [('prec', pymongo.ASCENDING)] self._sort_files = [('prec', pymongo.ASCENDING)] emf_logger.debug(self._add_to_fs_query) super(WebEigenvalues,self).update_from_db(**kwargs) #remember the precision we got after updating for every query (not only update_from_db uses this) self._add_to_fs_query = {'prec': {'$gt': int(self.prec-1)}}
def WebNewForm_cached(level,weight,character,label,parent=None, **kwds): if use_cache: M = WebModFormSpace_cached(level, weight, character, **kwds) return M.hecke_orbits[label] else: F = WebNewForm(level,weight,character,label,**kwds) emf_logger.debug("Computed F not using cache!") return F
def __init__(self, dbname='', **kwds): MFDisplay.__init__(self, dbname, **kwds) import lmfdb.base Conn = lmfdb.base.getDBConnection() #if dbname == '': dbname = 'modularforms2' self._files = Conn[dbname].Newform_factors.files emf_logger.debug("files : {0}".format(self._files))
def file_key_dict(self): r""" Return a dictionary where the keys are the dbkeys of ``self``` and the values are the corresponding values of ```self```. """ emf_logger.debug('key: {0}'.format(self._key)) #emf_logger.debug('properties: {0}'.format(self._properties)) return { key : self._properties[key].to_db() for key in self._file_key }
def init_dynamic_properties(self): if self.number is not None: emf_logger.debug('number: {0}'.format(self.number)) self.character = DirichletCharacter_conrey( DirichletGroup_conrey(self.modulus), self.number) self.sage_character = self.character.sage_character() self.name = "Character nr. {0} of modulus {1}".format( self.number, self.modulus)
def file_key_dict(self): r""" Return a dictionary where the keys are the dbkeys of ``self``` and the values are the corresponding values of ```self```. """ emf_logger.debug('key: {0}'.format(self._key)) #emf_logger.debug('properties: {0}'.format(self._properties)) return {key: self._properties[key].to_db() for key in self._file_key}
def __init__(self, dbname='', **kwds): emf_logger.debug("in ClassicalMFDisplay kwds={0}".format(kwds)) MFDisplay.__init__(self, dbname, **kwds) import lmfdb.base Conn = lmfdb.base.getDBConnection() #if dbname == '': dbname = 'modularforms2' self._files = Conn[dbname].Newform_factors.files emf_logger.debug("files db : {0} with nr. of recs:{1}".format(self._files,self._files.find().count()))
def init_dynamic_properties(self): from lmfdb.modular_forms.elliptic_modular_forms.backend.emf_utils import dirichlet_character_conrey_galois_orbit_embeddings if self.number is not None: emf_logger.debug('number: {0}'.format(self.number)) self.character = DirichletCharacter_conrey(DirichletGroup_conrey(self.modulus),self.number) self.sage_character = self.character.sage_character() self.name = "Character nr. {0} of modulus {1}".format(self.number,self.modulus) emb = dirichlet_character_conrey_galois_orbit_embeddings(self.modulus,self.number) self.set_embeddings(emb)
def __init__(self, dbname="", **kwds): MFDisplay.__init__(self, dbname, **kwds) import lmfdb.base Conn = lmfdb.base.getDBConnection() # if dbname == '': dbname = "modularforms2" self._files = Conn[dbname].Newform_factors.files emf_logger.debug("files : {0}".format(self._files))
def __init__(self, dbname='', **kwds): emf_logger.debug("in ClassicalMFDisplay kwds={0}".format(kwds)) MFDisplay.__init__(self, dbname, **kwds) import lmfdb.base Conn = lmfdb.base.getDBConnection() #if dbname == '': dbname = 'modularforms2' self._files = Conn[dbname].Newform_factors.files emf_logger.debug("files db : {0} with nr. of recs:{1}".format(self._files,self._files.find().count()))
def __init__(self, name, level, weight, character, parent=None,**kwds): emf_logger.debug("Get Hecke orbits! {0},{1},{2},{3},{4},kwds={5}".format(name,level,weight,character,type(parent),kwds)) self.level = level self.weight = weight self.character = character self.parent = parent super(WebHeckeOrbits, self).__init__( name, None, save_to_db=True, save_to_fs=False,**kwds ) emf_logger.debug("Initiated Hecke orbits!")
def browse_web_modform_spaces_in_ranges(**kwds): r""" Browse spaces with level and weight within given ranges. level and weight should be of the form N1-N2 and k1-k2 """ emf_logger.debug("request.args={0}".format(request.args)) level=request.args.getlist('level') weight=request.args.getlist('weight') group=request.args.getlist('group') return _browse_web_modform_spaces_in_ranges(level=level,weight=weight,group=group)
def redirect_false_route(level=None,weight=None,character=None,label='',emb=None): ## jumps only have one field (here level) if weight is None: args = extract_data_from_jump_to(level) emf_logger.debug("args={0}".format(args)) else: args = {'level':level,'weight':weight,'character':character,'label':label} #validate_parameters(level,weight,character,label,args) return redirect(url_for("emf.render_elliptic_modular_forms",**args), code=301)
def redirect_false_route(level=None,weight=None,character=None,label='',emb=None): ## jumps only have one field (here level) if weight is None: args = extract_data_from_jump_to(level) emf_logger.debug("args={0}".format(args)) else: args = {'level':level,'weight':weight,'character':character,'label':label} #validate_parameters(level,weight,character,label,args) return redirect(url_for("emf.render_elliptic_modular_forms",**args), code=301)
def browse_web_modform_spaces_in_ranges(**kwds): r""" Browse spaces with level and weight within given ranges. level and weight should be of the form N1-N2 and k1-k2 """ emf_logger.debug("request.args={0}".format(request.args)) level=request.args.getlist('level') weight=request.args.getlist('weight') group=request.args.getlist('group') return render_elliptic_modular_form_navigation_wp(level=level,weight=weight,group=group)
def get_coefficients(info): r""" Return a file with the Fourier coefficients in desired format. """ emf_logger.debug("IN GET_COEFFICIENTS!!!") level = my_get(info, 'level', -1, int) weight = my_get(info, 'weight', -1, int) character = my_get(info, 'character', '', int) # int(info.get('weight',0)) number = my_get(info, 'number', 100, int) label = my_get(info, 'label', '', str) emf_logger.debug("info={0}".format(info)) if character == '': character = 1 label = info.get('label', '') if info['format'] == "sage": ending = "sage" f = WebNewForm(level, weight, character, label, prec=number) s = f.download_to_sage(number) elif info['format'] == "sobj": ending = "sobj" f = WebNewForm(level, weight, character, label, prec=number) s = f.dump_coefficients(number) else: # we only want one form or one embedding try: s = print_list_of_coefficients(info) except IndexError as e: info['error'] = str(e) flask.flash(str(e)) return redirect(url_for("emf.render_elliptic_modular_forms", level=level, weight=weight, character=character, label=label), code=301) ending = "txt" if info['format'] == 'q_expansion': fmt = '-qexp' elif info['format'] == "coefficients" or info['format'] == "sobj": fmt = '-coef' elif info['format'] == "embeddings": fmt = '-emb' else: fmt = '' info['filename'] = "{0}-{1}-{2}-{3}-coefficients-0-to-{4}{5}.{6}".format( level, weight, character, label, number, fmt, ending) # return send_file(info['tempfile'], as_attachment=True, attachment_filename=info['filename'], add_etags=False) strIO = StringIO.StringIO() strIO.write(s) strIO.seek(0) return send_file(strIO, attachment_filename=info["filename"], as_attachment=True, add_etags=False)
def authorize(cls): r""" Need to be authorized to insert data """ from os.path import dirname, join pw_filename = join(dirname(dirname(__file__)), "password") user = '******' password = open(pw_filename, "r").readlines()[0].strip() emf_logger.debug("Authenticating user={0} password={1}".format(user,password)) cls.connect_to_db().authenticate(user,password) emf_logger.debug("Authenticated with user:{0} and pwd:{1}".format(user,password))
def file_key_dict(self, include_multi=True): r""" Return a dictionary where the keys are the dbkeys of ``self``` and the values are the corresponding values of ```self```. """ emf_logger.debug('key: {0}'.format(self._key)) #emf_logger.debug('properties: {0}'.format(self._properties)) keys = copy(self._file_key) if include_multi and self._file_key_multi is not None: keys += self._file_key_multi return {key: self._properties[key].to_db() for key in keys}
def authorize(cls): r""" Need to be authorized to insert data """ from os.path import dirname, join pw_filename = join(dirname(dirname(__file__)), "password") user = '******' password = open(pw_filename, "r").readlines()[0].strip() emf_logger.debug("Authenticating user={0} password={1}".format(user,password)) cls.connect_to_db().authenticate(user,password) emf_logger.debug("Authenticated with user:{0} and pwd:{1}".format(user,password))
def compute_values(self, save=False): emf_logger.debug('in compute_values for WebChar number {0} of modulus {1}'.format(self.number, self.modulus)) if self._values_algebraic == {} or self._values_float == {}: changed = True for i in range(self.modulus): self.value(i,value_format='float') self.value(i,value_format='algebraic') if changed and save: self.save_to_db() else: emf_logger.debug('Not saving.')
def file_key_dict(self, include_multi = True): r""" Return a dictionary where the keys are the dbkeys of ``self``` and the values are the corresponding values of ```self```. """ emf_logger.debug('key: {0}'.format(self._key)) #emf_logger.debug('properties: {0}'.format(self._properties)) keys = copy(self._file_key) if include_multi and self._file_key_multi is not None: keys += self._file_key_multi return { key : self._properties[key].to_db() for key in keys }
def __init__(self, name, level, weight, character, parent=None, prec=10, **kwds): emf_logger.debug("Get Hecke orbits! {0},{1},{2},{3},{4},kwds={5}".format(name,level,weight,character,type(parent),kwds)) self.level = level self.weight = weight self.character = character self.parent = parent self.prec = prec super(WebHeckeOrbits, self).__init__( name, None, save_to_db=True, save_to_fs=False,**kwds ) emf_logger.debug("Initiated Hecke orbits!")
def render_web_newform(level, weight, character, label, **kwds): r""" Renders the webpage for one elliptic modular form. """ # citation = ['Sage:' + version()] # never used info = set_info_for_web_newform(level, weight, character, label, **kwds) emf_logger.debug("info={0}".format(info.keys())) ## Check if we want to download either file of the function or Fourier coefficients if 'download' in info and 'error' not in info: return send_file(info['tempfile'], as_attachment=True, attachment_filename=info['filename']) return render_template("emf_web_newform.html", **info)