Code Monkey home page Code Monkey logo

modularforms.jl's Introduction

ModularForms.jl

implementation of modular forms algorithms in Julia

Build Status

Getting started

  1. Install Julia.
  2. Install Nemo: at the Julia prompt, press ] to access the package manager, then:
(v1.0) pkg> add Nemo
  1. Press Backspace to exit the package manager.
  2. Start Julia from ModularForms.jl directory.
  3. Activate ModularForms.jl: press ] to access package manager, then
(v1.0) pkg> activate .
  1. (Optional) Test:
(v1.0) pkg> test

modularforms.jl's People

Contributors

aghitza avatar lengelberts avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar

Forkers

carlosal1015

modularforms.jl's Issues

To do (Lynn)

  • 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)?

Default and keyword arguments

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")).

About the change from polynomials to power series

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).

To do after the break (for Lynn)

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

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    ๐Ÿ–– Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. ๐Ÿ“Š๐Ÿ“ˆ๐ŸŽ‰

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google โค๏ธ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.