Ideas for future development

Class akima_interp
It appears that the interp() function below searches for indices slightly differently than the original GSL eval() function. This should be checked, as it might be slightly non-optimal in terms of speed (shouldn't matter for the accuracy).

Class base_interp
These might work for decreasing functions by just replacing calls to search_vec::bsearch_inc() with search_vec::bsearch_dec(). If this is the case, then this should be rewritten accordingly. (I think I might have removed the acceleration)

Class cern_adapt
Allow user to set the initial segments?

Class cern_gauss
Allow user to change cst?

Class cern_mroot
Modify this so it handles functions which return non-zero values.

Class cern_mroot
Move some of the memory allocation out of msolve()

Class cern_mroot
Give the user access to the number of function calls

Class cern_mroot_root
Double-check this class to make sure it cannot fail while returning 0 for success.

Class contour
  • Work on how memory is allocated
  • Create a new separate struct for contour curves

Class deriv
Improve the methods for second and third derivatives

Class deriv
This does not have pure virtual functions, but I'd still like to prevent the user from directly instantiating a deriv object.

Class file_detect
Allow the user to specify the compression commands in configure, or at least specify the path to gzip, bzip2, etc.

Class gsl_anneal
Implement a more general simulated annealing routine which would allow the solution of discrete problems like the Traveling Salesman problem.

Class gsl_anneal
Implement a method which automatically minimizes within some specified tolerance?

Class gsl_astep
Fix so that memory allocation/deallocation is performed only when necessary

Class gsl_astep
Allow user to find out how many steps were taken, etc.

Class gsl_chebapp
Implement eval_err(), eval_n() and eval_n_err() methods.

Class gsl_deriv
Include the forward and backward GSL derivatives

Class gsl_inte_cheb
Make cern_cauchy and this class consistent in the way which they require the user to provide the denominator in the integrand

Global gsl_inte_kronrod::gsl_integration_qk_o2scl (func_t &func, const int n, const double xgk[], const double wg[], const double wgk[], double fv1[], double fv2[], double a, double b, double *result, double *abserr, double *resabs, double *resasc, param_t &pa)
This function, in principle, could be replaced with a generic integration pointer.

Class gsl_inte_qng
Compare directly with GSL as is done in gsl_inte_qag_ts.

Global gsl_inte_singular::qags (func_t &func, const int qn, const double xgk[], const double wg[], const double wgk[], double fv1[], double fv2[], const double a, const double b, const double l_epsabs, const double l_epsrel, const size_t limit, double *result, double *abserr, param_t &pa)
Remove goto statements?

Class gsl_inte_singular::extrapolation_table
Move this to a new class, with qelg() as a method

Class gsl_inte_table
Move gsl_integration_workspace to a separate class and remove this class, making all children direct descendants of gsl_inte instead. We'll have to figure out what to do with the data member wkspace though. Some work on this front is already in gsl_inte_qag_b.h.

Class gsl_mmin_wrapper
There's a bit of extra vector copying here which could potentially be avoided.

Class gsl_root_stef
There's some extra copying here which can probably be removed.

Class gsl_root_stef
Compare directly to GSL.

Class gsl_vegas
Could convert bins and boxes to a more useful structure

Class lanczos
The function eigen_tdiag() automatically sorts the eigenvalues, which may not be necessary.

Class minimize
This does not have pure virtual functions, but I'd still like to prevent the user from directly instantiating a minimize object.

Global minimize::bracket (double &ax, double &bx, double &cx, double &fa, double &fb, double &fc, param_t &pa, func_t &func)
Improve this algorithm with the standard golden ratio method?

Class nonadapt_step
Modify so that memory allocation/deallocation is only performed when necessary

Class ode_bv_shoot
Implement shooting from an internal point, either using a different class or using this one.

Global ode_iv_solve::solve_table (double x0, double x1, double h, size_t n, vec_t &ystart, size_t &nsol, vec_t &xsol, mat_t &ysol, param_t &pa, func_t &derivs)
Consider modifying so that this can handle tables which are too small by removing half the rows and doubling the stepsize.

Class omatrix_view_tlate
This class isn't sufficiently general for some applications, such as sub-matrices of higher-dimensional structures. It might be nice to create a more general class with a "stride" and a "tda".

Class omatrix_view_tlate
The xmatrix class demonstrates how operator[] could return an ovector_array object and thus provide better bounds-checking. This would demand including a new parameter in omatrix_view_tlate which contains the vector type.

Class other_todos_and_bugs
There may be a problem with const-correctness in vectors. I'm not sure how it's best solved. It could be best to create two kinds of ovector_view's: one const and one not. 10/19/07: I think it's the case that neither ovector_const_subvector, or const ovector_subvector are truly const, but it's only const ovector_const_subvector that would be truly const. I'm not sure if this is related to the issue of constness in ovector_view discussed above.

Class other_todos_and_bugs
Consider breaking documentation up into sections?

Class ovector_view_tlate
Consider an operator== ?

Class pinside
The inside() functions actually copy the points twice. This can be made more efficient.

Class planar_intp
Rewrite so that it never fails unless all the points in the data set lie on a line. This would probably demand sorting all of the points by distance from desired location.

Class root
This does not have pure virtual functions, but I'd still like to prevent the user from directly instantiating a root object.

Class simple_jacobian
GSL-1.10 updated fdjac.c and this update could be implemented below.

Class table
Be more restrictive about allowable column names

Class table
Add interp() and related functions which avoid caching and can thus be const (This has been started with interp_const() )

Class table
The nlines vs. maxlines and automatic resizing of table-owned vs. user-owned vectors could be reconsidered, especially now that ovectors can automatically resize on their own. 10/16/07: This issue may be unimportant, as it might be better to just move to a template based approach with a user-specified vector type. The interpolation is now flexible enough to handle different types. Might check to ensure sorting works with other types.

Class table
The present structure, std::map<std::string,col,string_comp> atree and std::vector<aiter> alist; could be replaced with std::vector<col> list and std::map<std::string,int> tree where the map just stores the index of the the column in the list

Class tensor
Could implement arithmetic operators + and - and some different products.

Class tensor
Add slicing to get ovector or omatrix objects

Class tensor_grid
Only allocate space for grid if it is set

Class tensor_grid
Could implement arithmetic operators + and - and some different products.

Global tensor_grid::set_grid (double **val)
Define a more generic interface for matrix types

Global tensor_grid::interpolate (double *vals)
It should be straightforward to improve the scaling of this algorithm significantly by creating a "window" of local points around the point of interest. This could be done easily by constructing an initial subtensor.

Class test_mgr
test_mgr::success and test_mgr::last_fail should be protected, but that breaks the operator+() function. Can this be fixed?

Class twod_intp
Could also include mixed second/first derivatives: deriv_xxy and deriv_xyy.

Class twod_intp
Implement an improved caching system in case, for example xfirst is true and the last interpolation used the same value of x.

Global twod_intp::set_interp (size_t ni, base_interp< ovector_view > *it, base_interp< ovector_const_subvector > *it_sub, base_interp< ovector_view > &it2, base_interp< ovector_const_subvector > &it2_sub)
Use std::vector for the first two base_interp arguments?

Class uvector_cx_view_tlate
Write lookup() method, and possibly an erase() method.

Class uvector_view_tlate
Could allow user-defined specification of restrict keyword

File cblas_base.h
Convert to size_t and add float and complex versions

Global dscal_subcol
Implement explicit loop unrolling

Global daxpy_hv_sub
Implement explicit loop unrolling

Global ddot_hv_sub
Implement explicit loop unrolling

Global err_assert
Make this consistent with assert() using NDEBUG?

Global LU_invert
could rewrite to avoid mat_col_t

Global operator<<
This assumes that scientific mode is on and showpos is off. It'd be nice to fix this.

Global solve_tridiag_sym
Convert into class for memory managment and combine with other functions below

File vec_arith.h
Define operators for complex vector * real matrix

File vec_arith.h
These should be replaced by the BLAS routines where possible?

Global matrix_cx_copy_gsl
At present this works only with complex types based directly on the GSL complex format. This could be improved.

Global vector_cx_copy_gsl
At present this works only with complex types based directly on the GSL complex format. This could be improved.

Documentation generated with Doxygen and provided under the GNU Free Documentation License. See License Information for details.

Project hosting provided by SourceForge.net Logo, O2scl Sourceforge Project Page