Context Navigation

Changes between Version 18 and Version 19 of SoC2016

Timestamp:: Feb 19, 2016, 12:40:34 PM (7 years ago)
Author:: Niall Douglas
Comment:: admin copy editing pass

Legend:

: Unmodified
: Added
: Removed
: Modified

SoC2016

-              v18
+              v19
 Boost.odeint  http://www.odeint.com is a library devoted to finding numerical solutions of ordinary differential equations (ODEs). It is developed in a generic way using Template Metaprogramming which leads to extraordinary high flexibility at top performance. It is widely used in academic and industrial projects. Boost.odeint has been a Google Summer of Code project in [https://www.google-melange.com/gsoc/project/details/google/gsoc2011/mulansky/5724160613416960 2011] and [https://www.google-melange.com/gsoc/project/details/google/gsoc2013/earnocks/5872285445521408 2013] and we would like again to see students involved in the development of this numerical library.
 ==== Project 1: Implicit Routines ====
+==== Project Idea 1: Implicit Routines ====
 The current focus of odeint is on '''explicit''' routines, namely the Runge-Kutta schemes or the multi-step methods. However, we would like to expand odeint by adding implicit routines in the same flexible manner. Implicit routines are important when dealing with stiff systems, but also ensure stability in some cases of discretized partial differential equations (PDEs). At the moment, odeint provides an implicit Euler and Rosenbrock algorithm, but the implementation is restricted to Boost.uBlas. As one of the main objectives of odeint is to provide highly flexible algorithms, we want to change this implementation to have a greater flexibility and interchangeability similar to that of the explicit routines. This project would not only require pure coding, but first also a considerable amount of design work.
 …
  * Implement a prototype showing the usability of the design
  * Change the existing routines to the new design
  * Implement other backends (MTL, eigen,...) to demonstrate the flexibility
+ * Implement other backends (MTL, eigen, ...) to demonstrate the flexibility
  * Provide examples and documentation
  * (Add more implicit routines, if time permits)
 ==== Project 2: Event Detection ====
 Currently, Boost.odeint does not offer specific functionality for event detection. However, this is a common use-case and has been discussed on the [https://github.com/headmyshoulder/odeint-v2/issues/9 odeint Github page] in the past. Some examplary implementation of an event-detection algorithm was added recently as [https://github.com/headmyshoulder/odeint-v2/commit/766d2cb0631b89f8f7f5c8187b792a216e691bd9#diff-8cd5c8387c683493559d40540e0a4f0c an example]. On the other hand, sophisticated event detection algorithms have been explored in the context of [http://www.sciencedirect.com/science/article/pii/0167278982900343 computing Poincare sections]. The first task of this project, however, is to develop a clean, generic interface to incorporate event detection algorithms into the existing structure of Boost.odeint.
+==== Project Idea 2: Event Detection ====
+Currently, Boost.odeint does not offer specific functionality for event detection. However, this is a common use-case and has been discussed on the [https://github.com/headmyshoulder/odeint-v2/issues/9 odeint Github page] in the past. An investigatory implementation of an event-detection algorithm was added recently as [https://github.com/headmyshoulder/odeint-v2/commit/766d2cb0631b89f8f7f5c8187b792a216e691bd9#diff-8cd5c8387c683493559d40540e0a4f0c an example]. On the other hand, sophisticated event detection algorithms have been explored in the context of [http://www.sciencedirect.com/science/article/pii/0167278982900343 computing Poincare sections]. The first task of this project, however, is to develop a clean, generic interface to incorporate event detection algorithms into the existing structure of Boost.odeint.
 The project requires profound knowledge of C++ and generic programming, as well as a good understanding of Boost.odeint and ODE simulations and numerical algorithms.
 …
 This project requires knowledge of C++11 and Python
+Potential projects:
+==== Potential projects: ====
 * Modernize code base by using standard C++11 features rather than their equivalent Boost APIs (type traits, notably).
 * Integrate NumPy support into Boost.Python (https://github.com/ndarray/Boost.NumPy), or prepare for stand-alone review.
 === 4. Boost.uBLAS ===
 Potential mentors: David Bellot
 …
 uBLAS is a library for linear algebra and matrix computations. Using recursive templates, it allows the compiler to optimize any complex linear algebra expressions as if it were written by hand by the programmer. Basic classes are matrix and vector. The library has all the basic functionalities and a few standard algorithms. We would like to improve the functionality of this library by adding new algorithms and functionality especially in the field of data analysis and machine learning.
+==== Project 1: Data Frame and Statistics ====
+Languages like R or Python (with Pandas) uses the notion of Data Frame and have many aggregation or grouping algorithm to generate all sorts of statistics on huge matrices. As it became a very important topic we would like to have similar functions in uBLAS. For example you can see libraries like Pandas ( http://pandas.pydata.org/pandas-docs/dev/generated/pandas.DataFrame.html) or a very powerful R package name data.table ( http://cran.r-project.org/web/packages/data.table/index.html). Having similar functionalities in ublas would be a must !
+The project will require to understand the basics of R data.frame and see what kind of limitations arise when it has to be implemented with a template meta-program in C++. However, the project will require the student to also identify all the possible optimizations than can't be done with generic purpose data.frame in R and Python because of missing information (like column types), etc...
+==== Project Idea 1: Data Frame and Statistics ====
+Languages like R or Python (with Pandas) uses the notion of Data Frame and have many aggregation or grouping algorithm to generate all sorts of statistics on huge matrices. As it became a very important topic we would like to have similar functions in uBLAS. For example you can see libraries like Pandas ( http://pandas.pydata.org/pandas-docs/dev/generated/pandas.DataFrame.html) or a very powerful R package name data.table ( http://cran.r-project.org/web/packages/data.table/index.html). Having similar functionalities in ublas would be a must!
+The project will require the student to understand the basics of R data.frame and see what kind of limitations arise when it has to be implemented with a template meta-program in C++. However, the project will require the student to also identify all the possible optimizations that can't be done with generic purpose data.frame in R and Python because of missing information (like column types), etc...
 Finally, the student is expected to implement algorithms on the data.frame that can potentially be re-used on matrices too like subset selection with generic operators, statistics and summaries. Understanding memory management, alignment, optimizations, vector processing is not mandatory but most welcome.
+Understanding expression template and meta-programming in C++ is required.
+Understanding C++ expression template and C++ meta-programming is required.
 The student will start by studying existing implementations and propose a design. Then he or she will implement a prototype with tests and benchmarks. The final stage will be a thorough integration into ublas, and especially writing examples and documentation.
 ==== Project 2:  Statistics and data analysis ====
+==== Project Idea 2:  Statistics and data analysis ====
 This project is about adding statistical capabilities to Boost.uBLAS. It requires a deep understanding of C++ and of basics and if possible advanced statistics. In term of work, it will require to add many functions to compute mean, variance, covariance, histogram, several types of running statistics on long vector or matrices.
+This project requires a lot of attention to the detail as all the functions must be thoroughly tested for all types of data. They have to be as generic as possible and works on most of the types.
+This project requires a lot of attention to the detail as all the functions must be thoroughly tested for all types of data. They have to be as generic as possible and work on most of the types.
 If time permits, but it is almost a second requirement, we would like to see implementation of simple machine learning algorithm like k-means clustering, Gaussian mixtures, PCA, ICA and possible other types of simple mixtures. The student will need to understand those techniques beforehand.
 …
 A programming competency test is required.
+It is asked to the candidates to implement a Toeplitz matrix in uBLAS. You can get your inspiration from how the banded matrices are implemented, like here: https://github.com/uBLAS/ublas/blob/master/include/boost/numeric/ublas/banded.hpp
+It is asked of the candidates to implement a Toeplitz matrix in uBLAS. You can get your inspiration from how the banded matrices are implemented, like here: https://github.com/uBLAS/ublas/blob/master/include/boost/numeric/ublas/banded.hpp
 If you are selected as a student and if your implementation is good enough, as a bonus we will integrate your programming competency test into the code of uBLAS.
 …
 [http://www.boost.org/libs/flyweight/doc/index.html Boost.Flyweight] allows for memory-efficient handling of large quantities of immutable objects when many of them have equivalent states, i.e. when their representation can be reduced to a smaller number of surrogate instances. These common representatives are stored and looked up in so-called ''[http://www.boost.org/libs/flyweight/doc/reference/factories.html#factory factories]''. As it happens, flyweight factories are one-keyed, i.e. they can only be looked up by values of one type (either that of the elements stored themselves, in the default case, or a user-specified type for ''[http://www.boost.org/libs/flyweight/doc/tutorial/key_value.html key-value flyweights]''). Sometimes the need arises of specifying more than one key type by which the same underyling objects can be accessed, naturally leading to an extended concept of ''multi-key factories'', which as of today are not part of Boost.Flyweight. More context is given in a recent [http://thread.gmane.org/gmane.comp.lib.boost.devel/265379 thread] on the Boost mailing list.
 ==== Project: multi-key flyweights ====
 Let `Key1`, ... , `KeyN` be types with some notion of identity ~ under which they are isomorphic, i.e. there are mappings `fij(Keyi)->Keyj` that preserve intra-type identity, and let be `Value` be some other, different type (the flyweight type). A multi-key flyweight on (`Key1`, ... , `KeyN`, `Value`) is a type `M` that behaves as a key-value flyweight for each (`Keyi`, `Value`)  with the additional property that
+==== Project Idea: multi-key flyweights ====
+Let `Key1`, ... , `KeyN` be types with some notion of identity ~ under which they are isomorphic, i.e. there are mappings `fij(Keyi)->Keyj` that preserve intra-type identity, and let be `Value` be some other, different type (the flyweight type). A multi-key flyweight on (`Key1`, ... , `KeyN`, `Value`) is a type `M` that behaves as a key-value flyweight for each (`Keyi`, `Value`) with the additional property that:
 `ki` ~ `kj` <=> `M(ki)==M(kj)` for each 1 <= `i`, `j` <= `N`, `ki` of type `Keyi`, `ki` of type `Keyj`,
 that is, equivalent keys (even if of different types) refer to the same object, and conversely. The goal of the project is to extend Boost.Flyweight to support these multi-key flyweights. Some of the items to be completed will be:
+... that is, equivalent keys (even if of different types) refer to the same object, and conversely. The goal of the project is to extend Boost.Flyweight to support these multi-key flyweights. Some of the items to be completed will be:
 * Define the concepts required for multi-key factories and their specifiers, in a manner consistent and interoperable with the existing concepts for [http://www.boost.org/libs/flyweight/doc/reference/holders.html#holder holders], [http://www.boost.org/libs/flyweight/doc/reference/locking.html#locking locking policies] and [http://www.boost.org/libs/flyweight/doc/reference/tracking.html#tracking tracking policies]. As a kind of sanity check, the concept of multi-key factory when the number of keys is 1 should coincide with the already existing concept of factory.
 …
 * Provide full docs (tutorial and reference), examples and full test coverage to be merged with existing Boost.Flyweight material.
-==== Potential project extension funded by Boost ====
-The student is asked to work in this project as long as required to submit an industry-grade piece of work to the consideration of the Boost community, which should not but might extend beyond GSoC timelines. No additional funding from Boost is available.
 ==== Skills and competency test ====