aghitza / modularforms.jl Goto Github PK

• Write tests for Hecke basis, especially for space of modular forms.
• Make a poster.
• Check out Documenter.jl and add documentation.
• Write victor_miller_basis immediately as a power series and see if this is more efficient. (How about eisenstein_series_qexp?)
• (Optional) Add more tests related to tests used in the Sage code.
• Benchmarking.

Questions:

• Do we want to change some arguments to keyword arguments?
• Do we want to be more specific about the type of input arguments (via the :: operator)?
• Can we delete generators.jl or do we want to redefine Delta16() etc. using delta_k_qexp(16)?

write benchmarks for the modular forms code using

https://github.com/JuliaCI/BenchmarkTools.jl

The REQUIRE file could not be found.
cc: @aghitza

The following functions do now only have a power series version:

• hecke_operator_on_qexp (and the prime versions)
• generators: Delta16, etc.

The following functions have both a polynomial and a power series implementation:

• delta: delta_poly and delta_qexp
• Eisenstein series: eisenstein_series_poly and eisenstein_series_qexp
• VM basis: victor_miller_basis_poly and victor_miller_basis

Questions:

• Do I want to define eisenstein_series_qexp via eisenstein_series_poly and big_oh or do I keep it like this? Now not using eisenstein_series_poly.
• Do I want to define victor_miller_basis immediately s.t. the output is in terms of power series or do I keep the current version where it uses victor_miller_basis_poly and big_oh?
  NOTE: If I change it, I need to be aware that I have used the polynomial versions for delta, E4, and E6 (and hence need to adapt these to the power series versions).

We just need to copy them from src/delta.jl or so.

To do:

• Adapt hecke_operator_on_qexp such that it returns a power series up to the correct precision.
• Complete tests for eisenstein_series_poly, eisenstein_series_qexp, the generators, and victor_miller_basis.
• Write function for eta-product/-quotient.
• Improve big_oh.
• Extend the functions delta_poly, delta_qexp, eisenstein_series_poly, and eisenstein_series_qexp such that they work for all rings (instead of only ZZ or QQ, resp.).
  NOTE: then need to adapt tests!
• Extend the functions hecke_operator_on_qexp and hecke_operator_on_basis to the space of all modular forms (instead of only cusp forms).

In addition, fix (currently not working as it should):

• hecke_operator_on_qexp for n = 1. Currently only returns 1. PROBLEM. (For now, test commented so that tests keep running.)
• victor_miller_basis now returns an array consisting of fmpq_rel_series elements instead of fmpz_rel_series.

Check comments in files:

• Check Sage implementation of hecke_operator_on_basis.
• Comment about prec in eisenstein_series_qexp. How do we define prec for the PowerSeriesRing?
  NOTE: In each function where we define a PowerSeriesRing I have used the input argument prec. So if need to update, also need to check the other files if need to change.

Other:

• Update README.md.
• Update LICENSE.md.
• Create a .travis.yml file.
• Continue setting up as a module (see below for relevant sources).
• Running tests now takes very long. It might be good to look for a way to optimise it.

Sources about setting up as a module and testing

• http://abelsiqueira.github.io/blog/automated-testing/
• http://www.stochasticlifestyle.com/finalizing-julia-package-documentation-testing-coverage-publishing/

The tag name "v0.1" is not of the appropriate SemVer form (vX.Y.Z).
cc: @aghitza

The REQUIRE file could not be found.
cc: @aghitza

It would be nice to be able to do the following:
eisenstein_series_qexp(24,20,normalization="integral")
instead of
eisenstein_series_qexp(24,20,QQ,"q","integral")
like is possible in Sage.
However, this seems to be impossible in Julia.

There seems to be the following options:

• Using optional arguments (as we are already doing):
  function foo(a=1,b=2)
a+b
end
  Then foo() returns 3, foo(2) returns 4, and foo(2,3) returns 5. But foo(b=3) returns an error.

• Using keyword arguments:
  function foo(;a=1,b=2)
a+b
end
  Note: If we would do function foo(a=1;b=2) ... only b would be a keyword argument.
  Then foo() returns 3, foo(a=2) returns 4, and foo(a=2,b=3) returns 5. But now foo(3) or foo(3,b=2) returns an error. So any argument that is a keyword argument needs to be called like foo(keyword=...). However, now it is possible to do foo(b=3) (i.e. only call the second argument) (which will return 4 and automatically take the default value for a).

So I think we need to choose between:

• being able to do eisenstein_series_qexp(24,20,normalization="integral") but then always need to write down normalization (so also with eisenstein_series_qexp(24,20,QQ,"q",normalization="integral")).

• always needing to put all arguments if want to do a different normalization, but not need to write down normalization= (i.e. eisenstein_series_qexp(24,20,QQ,"q","integral")).