Ideas for Future Development
File cblas_base.h

Add float and complex versions?

There are some Level-1 BLAS functions which are already present in vector.h. Should we move all of them to one place or the other? The ones in vector.h are generic in the sense that they can use doubles or floats, but the ones here can use either () or [].

Page File I/O with HDF5
Create an HDF file I/O example.
Page Minimization
Plot the spring function
Class o2scl::anneal_gsl< func_t, vec_t, rng_t >

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

Class o2scl::anneal_mt< func_t, vec_t, rng_t, rng_dist_t >
There may be a good way to remove the function indirection here to make this class a bit faster.
Member o2scl::array_2d_out (std::ostream &os, size_t nrows, size_t ncols, mat_t &A)
If all of the matrix elements are positive integers and scientific mode is not set, then we can avoid printing the extra spaces.
Member o2scl::array_2d_trans_out (std::ostream &os, size_t nrows, size_t ncols, mat_t &A)
If all of the matrix elements are positive integers and scientific mode is not set, then we can avoid printing the extra spaces.
Class o2scl::astep_gsl< vec_y_t, vec_dydx_t, vec_yerr_t, func_t >
Compare more directly to GSL
Class o2scl::bin_size
Finish this.
Class o2scl::cheb_approx
Move non-template functions to .cpp file.
Class o2scl::chi_fit_funct< vec_t, mat_t, fit_func_t >

Allow a user-specified Jacobian or make that into a separate class?

Default constructor?

Class o2scl::cli

Warn in run_interactive() when extra parameters are given

Include a "remove command" function

A replace command function, there's already some code in cli.cpp for this.

There's some code duplication between comm_option_run() and run_interactive()

Allow the user to set the tilde string

Disallow direct access to o2scl::cli::par_list in order to ensure parameter names do not contain whitespace

Member o2scl::cli::cli_gets (const char *c)
Think about whether or not this should be protected? (Possibly not, as it's extensively used by acolm.cpp)
Member o2scl::cli::process_args (std::string s, std::vector< cmd_line_arg > &ca, int debug=0)
There's a typecast in this function to (char *) from (const char *) which needs reworking.
Class o2scl::columnify

Move the screenify() functionality from misc.h into this class?

It might be better to allow the string table to be specified with iterators.

Consider a function which takes a o2scl::table object as input?

Class o2scl::contour

Copy constructor

Improve the algorithm to ensure that no contour line ends on an internal point. I am not sure the best way to do this, but it could be done recursively just by trying all possible links instead of just using the one that minimizes the distance.

Rewrite the code which adjusts the contour levels to ensure contours don't go through the data to adjust the internal copy of the data instead? This should be more accurate because we're perturbing one point instead of perturbing the entire line.

Change nx and ny to size_t?

It would be nice to have a function which creates a set of closed regions to fill which represent the data. However, this likely requires a completely new algorithm, because it's not easy to simply close the contours already generated by the calc_contours() function. There are, for example, several cases which are difficult to handle, such as filling a region in between several closed contours

Member o2scl::contour::get_data (size_t &sizex, size_t &sizey, ubvector *&x_fun, ubvector *&y_fun, ubmatrix *&udata)
There is probably a better way than returning pointers to the internal data.
Class o2scl::contour_line
Make this a subclass of o2scl::contour ? (12/12/16 Maybe not, as it is a generic concept which can be computed outside the o2scl::contour class.)
Class o2scl::convert_units

A remove_cache() and in_cache() function to test to see if a conversion is currently in the cache.

Ideally, a real C++ API for the GNU units command would be better.

Member o2scl::count_words (std::string str)
Make consistent with split_string().
Member o2scl::cubic_real_coeff_gsl::gsl_poly_complex_solve_cubic2 (double a, double b, double c, gsl_complex *z0, gsl_complex *z1, gsl_complex *z2)
I think the GSL function is now fixed, so we can fall back to the original GSL function here.
Class o2scl::deriv_base< func_t >
Improve the methods for second and third derivatives
Class o2scl::deriv_cern< func_t >

All of the coefficients appear to be fractions which could be replaced with exact representation?

Record the number of function calls?

Class o2scl::deriv_eqi< func_t, vec_t >
Finish the second and third derivative formulas.
Class o2scl::deriv_gsl< func_t >
Include the forward and backward GSL derivatives. These would be useful for EOS classes which run in to trouble for negative densities.
Class o2scl::edge_crossings
Make this a subclass of o2scl::contour .
Class o2scl::err_hnd_type
There may be an issue associated with the string manipulations causing errors in the error handler.
Member o2scl::expval_matrix::current_avg (mat_t &avg, mat2_t &std_dev, mat3_t &avg_err)
This should be made const.
Member o2scl::expval_matrix::current_avg_stats (mat_t &avg, mat2_t &std_dev, mat3_t &avg_err, size_t &m_block, size_t &m_per_block)

This should be made const.

Avoid the copy associated with vector_slice().

Member o2scl::expval_scalar::reblock_avg_stats (size_t new_blocks, double &avg, double &std_dev, double &avg_err, size_t &m_per_block) const
Use recurrence relation for averages here rather than dividing at the end.
Member o2scl::expval_vector::current_avg (vec_t &avg, vec2_t &std_dev, vec3_t &avg_err)
This can't be const because of ubmatrix_row in current_avg_stats(), but should be made const later.
Member o2scl::expval_vector::current_avg_stats (vec_t &avg, vec2_t &std_dev, vec3_t &avg_err, size_t &m_block, size_t &m_per_block)
This can't be const because of ubmatrix_row, but should be made const later.
Class o2scl::fit_bayes< fit_func_t, multi_func_t, vec_t >

Also make weight_fun() an object of type multi_func_t?

Offer two ways to do the evidence: direct MC or the interpolation method from SLB13

Build upon gen_fit_funct instead of fit_funct?

Class o2scl::fit_nonlin< func_t, vec_t, mat_t >
Some of these member functions (like update_diag()) don't depend on member data and could be possibly be moved to a parent class?
Class o2scl::format_float

Handle inf's and nan's correctly.

Allow change of string for the "+" sign for the exponent

Class o2scl::gen_test_number< tot >
Document what happens if tot is pathologically small.
Class o2scl::gradient< func_t, vec_t >
Consider making an exact_grad class for computing exact gradients.
Class o2scl::hist
  • Add a counter which counts the number of calls to update()?
  • Add conversions back and forth from GSL histograms
  • Create extend_lhs too?
  • Would be nice not to have to create a new o2scl::search_vec object in o2scl::hist::get_bin_index() (make a search_vec data member?)
  • Consider adding the analogs of the GSL histogram sampling functions (separate class?)
  • Add a function which computes the bin sizes?
  • Allow rebinning?
  • Add histograms of float and integer values
  • Allow addition and other operations for two histograms.
  • Make the interpolation functions const (this is a bit complicated because of o2scl::hist::set_reps_auto() ).
Class o2scl::hist_2d

Write a function to create a 1-d histogram from a 2-d histogram either by selecting one bin in one axis or by marginalizing over one direction.

Note that here, there is a conflict between implementing operator(size_t,size_t) to give matrix indexing of the histogram weights, and operator(double,double) to implement two-dimensional interpolation using the weights and the representatives. Currently neither is implemented, but maybe both should be implemented instead?

Class o2scl::inte< func_t >
It might be useful to have all of the integration classes report the number of function evaluations used in addition to the number of iterations which were taken
Class o2scl::inte_adapt_cern< func_t, nsub >
  • Allow user to set the initial subdivisions?
  • It might be interesting to directly compare the performance of this class to o2scl::inte_qag_gsl .
  • There is a fixme entry in the code which could be resolved.
  • Output the point where most subdividing was required?
Class o2scl::inte_gauss_cern< func_t >
Allow user to change cst?
Class o2scl::inte_gen< func_t, lfunc_t, ufunc_t, vec_t >
It might be interesting to construct a child class of o2scl::inte_gen which automatically transforms variables to a hypercube and then applies a child of o2scl::inte_multi to do the integration.
Class o2scl::inte_kronrod_gsl< func_t >
Convert 'double *' objects to ubvector
Member o2scl::inte_kronrod_gsl< func_t >::gauss_kronrod_base (func2_t &func, double a, double b, double *result, double *abserr, double *resabs, double *resasc)
This function, in principle, is an integration object in and of itself, and could be implemented separately as an object of type o2scl::inte.
Class o2scl::inte_qag_gsl< func_t >

There are a few fine-tuned parameters which should be re-expressed as data members in the convergence tests.

Should QUADPACK parameters in round-off tests be subject to adjustments by the end user?

Add functions to examine the contents of the workspace to detect regions where the integrand may be problematic; possibly call these functions automatically depending on verbosity settings.

Member o2scl::inte_qag_gsl< func_t >::qag (func_t &func, const double a, const double b, const double l_epsabs, const double l_epsrel, double *result, double *abserr)
Just move this function to integ_err().
Class o2scl::inte_qawc_gsl< func_t >
Make inte_cauchy_cern and this class consistent in the way which they require the user to provide the denominator in the integrand
Member o2scl::inte_qawo_gsl_sin< func_t >::qawo (func_t &func, const double a, const double epsabs, const double epsrel, inte_workspace_gsl *loc_w, gsl_integration_qawo_table *wf, double *result, double *abserr)
Remove goto statements.
Class o2scl::inte_singular_gsl< func_t >
Some of the functions inside this class could be moved out of header files?
Member o2scl::inte_singular_gsl< func_t >::extrap_table
Move this to a new class, with qelg() as a method
Member o2scl::inte_singular_gsl< func_t >::extrap_table
Move this to a new class, with qelg() as a method
Member o2scl::inte_singular_gsl< func_t >::qags (func_t &func, const double a, const double b, const double l_epsabs, const double l_epsrel, double *result, double *abserr)
Remove goto statements. Before this is done, it might be best to add some tests which fail in the various ways.
Class o2scl::interp2_neigh< vec_t >

Make a parent class for this and o2scl::interp2_planar.

Maybe interpm_idw subsumes this functionality and makes this class obsolete? Or is this specialization particularly efficient?

Class o2scl::interp2_planar< vec_t >
Make a parent class for this and o2scl::interp2_neigh.
Class o2scl::interp2_seq< vec_t, mat_t, mat_row_t >
Implement an improved caching system in case, for example xfirst is true and the last interpolation used the same value of x.
Class o2scl::interp_monotonic< vec_t, vec2_t >
Convert into fewer loops over the data
Class o2scl::interp_vec< vec_t, vec2_t >
Make version which copies vectors rather than storing pointers might be better and then has copy constructors.
Member o2scl::interpm_idw< vec_t >::derivs_err (size_t func_index, size_t point_index, vec3_t &derivs, vec3_t &errs) const
This function requires an extra copy from "ders" to "ders2" which could be removed.
Member o2scl::mcarlo_miser< func_t, vec_t, rng_t >::estimate_corrmc (func_t &func, size_t ndim, const vec_t &xl, const vec_t &xu, size_t calls, double &res, double &err, const ubvector &lxmid, ubvector &lsigma_l, ubvector &lsigma_r)
Remove the reference to GSL_POSINF and replace with a function parameter.
Class o2scl::mcarlo_vegas< func_t, vec_t, rng_t >

Prettify the verbose output

Allow the user to get information about the how the sampling was done, possibly by converting the bins and boxes into a structure or class.

Allow the user to change the maximum number of bins.

Member o2scl::min_base< func_t, dfunc_t >::bracket (double &ax, double &bx, double &cx, double &fa, double &fb, double &fc, func_t &func)
Improve this algorithm with the golden ratio method in gsl/min/bracketing.c?
Member o2scl::min_brent_gsl< func_t >::iterate ()
It looks like x_left and x_right can be removed. Also, it would be great to replace the one-letter variable names with something more meaningful.
Class o2scl::min_de_base< func_t, dfunc_t >
Create a version of o2scl::mmin_conf which implements a minimizer with this interface.
Class o2scl::min_quad_golden< func_t >
Take common elements of this and min_brent and move to a generic GSL minimizer type?
Class o2scl::mmin_bfgs2< func_t, vec_t, dfunc_t, auto_grad_t, def_auto_grad_t >
When the bfgs2 line minimizer returns a zero status, the minimization fails. When err_nonconv is false, the minimizer isn't able to update the x vector so the mmin() function doesn't return the best minimum obtained so far. This is a bit confusing, and could be improved.
Class o2scl::mmin_constr< func_t, dfunc_t, hfunc_t, vec_t >

Implement automatic computations of gradient and Hessian

Construct a more difficult example for the "examples" directory

Finish mmin() interface

Implement a direct computation of the hessian as the jacobian of the gradient

Class o2scl::mmin_constr_pgrad< func_t, dfunc_t, vec_t >

Replace the explicit norm computation below with the more accurate dnrm2 from linalg

Replace the generic variable 'tol' with 'tolf' or 'tolx' from o2scl::mmin_base.

Class o2scl::mmin_constr_spg< func_t, dfunc_t, vec_t >
There is some memory allocation which isn't deallocated until the destructor, and should be handled a bit more elegantly.
Class o2scl::mmin_simp2< func_t, vec_t >
Double check that the updates in gsl-1.13 are included here, and also add support for the nmsimplex2rand algorithm in GSL.
Class o2scl::mroot< func_t, vec_t, jfunc_t >
Change ntrial to size_t?
Class o2scl::mroot_cern< func_t, vec_t, jfunc_t >

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

Move some of the memory allocation out of msolve()

Give the user access to the number of function calls

Rename nier6, nier7, and nier8 to something sensible.

It may be that the O2scl native Householder transformations should be used here instead of the inline version given here.

Class o2scl::mroot_hybrids< func_t, vec_t, mat_t, jfunc_t >

Is all the setting of vectors and matrices to zero really necessary? Do they need to be executed even if memory hasn't been recently allocated?

Convert more ubvectors to vec_t.

Some more of the element-wise vector manipulation could be converted to BLAS routines.

It's kind of strange that set() sets jac_given to false and set_de() has to reset it to true. Can this be simplified?

Many of these minpack functions could be put in their own "minpack_tools" class, or possibly moved to be linear algebra routines instead.

There are still some numbers in here which the user could have control over, for example, the nslow2 threshold which indicates failure.

Member o2scl::mroot_hybrids_base::compute_df (size_t n, const vec2_t &ff_trial, const vec2_t &fl, ubvector &dfl)
Replace with daxpy?
Member o2scl::mroot_hybrids_base::compute_qtf (size_t N, const vec2_t &q2, const vec3_t &f2, vec4_t &qtf2)
This is just right-multiplication, so we could use the O2scl cblas routines instead.
Member o2scl::mroot_hybrids_base::compute_trial_step (size_t N, vec2_t &xl, vec2_t &dxl, vec2_t &xx_trial)
Replace with daxpy.
Member o2scl::mroot_hybrids_base::enorm (size_t N, const vec2_t &ff)
Replace this with dnrm2 from cblas_base.h
Class o2scl::ode_bsimp_gsl< func_t, jac_func_t, vec_t, mat_t >

More detailed documentation about the algorithm

Figure out if this should be a child of ode_step or astep. The function step_local() is actually its own ODE stepper and could be reimplemented as an object of type ode_step.

I don't like setting yerr to GSL_POSINF, there should be a better way to force an adaptive stepper which is calling this stepper to readjust the stepsize.

The functions deuf_kchoice() and compute_weights() can be moved out of this header file.

Rework internal arrays

Rework linear solver to be amenable to using a sparse matrix solver

Class o2scl::ode_bv_mshoot< func_t, mat_t, vec_t, vec_int_t >
Make a class which performs an iterative linear solver which uses sparse matrices like ode_it_solve?
Class o2scl::ode_it_solve< func_t, vec_t, mat_t, matrix_row_t, solver_vec_t, solver_mat_t >

Set up convergence error if it goes beyond max iterations

Create a GSL-like set() and iterate() interface

Implement as a child of ode_bv_solve ?

Max and average tolerance?

Allow the user to ensure that the solver doesn't apply the full correction

Class o2scl::ode_iv_solve< func_t, vec_t >
The form of solve_final_value() is very similar to that of astep_base::astep_full(), but not quite the same. Maybe should probably be made to be consistent with each other?
Member o2scl::ode_iv_solve< func_t, vec_t >::solve_grid (double h, size_t n, size_t nsol, vec_t &xsol, mat_t &ysol, mat_t &err_sol, mat_t &dydx_sol, func_t &derivs)
Consider making a version of grid which gives the same answers as solve_final_value(). After each proposed step, it would go back and fill in the grid points if the proposed step was past the next grid point.
Member o2scl::ode_iv_solve< func_t, vec_t >::solve_store (double x0, double x1, double h, size_t n, size_t &n_sol, vec_t &x_sol, mat_t &y_sol, mat_t &yerr_sol, mat_t &dydx_sol, func_t &derivs, size_t istart=0)
It might be possible to remove some extra copying by removing the yerrl and dydx vectors
Class o2scl::ode_iv_table< func_t, vec_t, alloc_vec_t, alloc_t >

It would be nice not to have to copy the results from a matrix into a table, but this may require a nontrivial modification of the ODE solvers and/or the table class.

One possible idea is to redo the name specification as a separate function, which allows one to either specify prefixes or full column names. We also need to figure out how to handle column units.

Class o2scl::pinside
The inside() functions actually copy the points twice. This can be made more efficient.
Class o2scl::polylog
  • Give error estimate?
  • Improve accuracy?
  • Use more sophisticated interpolation?
  • Add the series $Li(n,x)=x+2^{-n} x^2+3^{-n} x^3+...$ for $ x \rightarrow 0$?
  • Implement for positive arguments < 1.0
  • Make another polylog class which implements series acceleration?
Class o2scl::prob_dens_func
Give functions for mean, median, mode, variance, etc?
Class o2scl::quartic_real_gsl
Optimize value of cube_root_tol and compare more clearly to o2scl::quartic_real_gsl2
Class o2scl::quartic_real_gsl2
Optimize value of cube_root_tol and compare more clearly to o2scl::quartic_real_gsl
Class o2scl::rng_gsl
This will likely be completely replaced by the random number generators in the standard library.
Class o2scl::root< func_t, dfunc_t >
Maybe consider allowing the user to specify the stream to which 'verbose' information is sent.
Member o2scl::root_bkt< func_t, dfunc_t >::solve (double &x, func_t &func)
Return early if the bracketing procedure finds a root early?
Class o2scl::root_brent_gsl< func_t >

There is some duplication in the variables x_lower, x_upper, a, and b, which could be removed. Some better variable names would also be helpful.

Create a meaningful enum list for o2scl::root_brent_gsl::test_form.

Class o2scl::root_cern< func_t >
Double-check this class to make sure it cannot fail while returning 0 for success.
Member o2scl::root_cern< func_t >::eps
This number should probably default to one of the GSL tolerances.
Class o2scl::root_de< func_t, dfunc_t >
Implement the functions solve() and solve_bkt() for derivative solvers.
Class o2scl::root_stef< func_t, dfunc_t >

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

Compare directly to GSL.

This can probably be modified to shorten the step if the function goes out of bounds as in exc_mroot_hybrids.

Member o2scl::search_vec< vec_t >::ordered_lookup (const double x0) const
This function just uses the find functions and then adjusts the answer at the end if necessary. It might be possible to improve the speed by rewriting this from scratch.
Member o2scl::search_vec_ext< vec_t >::search_vec_ext (size_t nn, const vec_t &x)
Ensure this is fully tested for vectors with only one element.
Class o2scl::series_acc

Move the workspaces to classes?

Create an example

Class o2scl::smooth_gsl

Generalize to generic vector types. (Does this require reworking the GSL linear fitting routines? Doesn't matter now, the GSL linear fitting routines are now reworked.)

Possibly create a new gsl_bspline class which replaces the GSL bspline workspace

Allow user to probe chi squared and the covariance?

Member o2scl::split_string (std::string str, std::vector< std::string > &sv)
Add user-specified delimiters?
Class o2scl::table3d

Improve interpolation and derivative caching

Make a 'const' version of the interpolation functions

Should there be a clear_grid() function separate from clear_data() and clear_table()?

Allow the user to more clearly probe 'size_set' vs. 'xy_set'?

Member o2scl::table3d::read_gen3_list (std::istream &fin, int verbose=0)
It would be great to add a function which generates a text file in this format as well.
Class o2scl::table< vec_t >
  • Create a sort_column_names() or a function to arbitrarily rearrange the columns
  • 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.
  • Rewrite check_synchro into a full is_valid()-like sanity check
Class o2scl::table_units< vec_t >

The unit conversion object is now always a pointer to the global conversion object. This could be modified, so that each table can have it's own, but this might require HDF output of unit conversion objects.

Make table methods virtual? (not necessary yet since delete_column() isn't referred to internally)

Member o2scl::table_units< vec_t >::get_unit (size_t i) const
Is there a way to make this function have O(1) time rather than searching?
Class o2scl::tensor< vec_t, vec_size_t >

Create an operator[] for tensor and not just tensor1?

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

Implement copies to and from vector and matrices

Implement tensor contractions, i.e. tensor = tensor * tensor

Consider making a template type to replace double, e.g. value_t.

Could be interesting to write an iterator for this class.

Create an is_valid() function which checks sizes

Class o2scl::tensor_grid1< vec_t, vec_size_t >
Make rank-specific get_val and set_val functions?
Class o2scl::tensor_grid< vec_t, vec_size_t >

Is it really necessary that get_data() is public?

Only allocate space for grid if it is set

Consider creating a new set_grid() function which takes grids from an object like uniform_grid. Maybe make a constructor for a tensor_grid object which just takes as input a set of grids?

Member o2scl::tensor_grid< vec_t, vec_size_t >::interp_linear (vec2_size_t &v)
This starts with a small copy, which can be eliminated by creating a new version of interp_linear_power_two which accepts an offset vector parameter so that the first interpolation is offset. Remaining interpolations don't need to be offset because the tensor has to be created from the previous interpolation round.
Member o2scl::tensor_grid< vec_t, vec_size_t >::interp_linear_vec (vec2_size_t &v, size_t ifree, vec2_t &res)
This function could be more efficient.
Member o2scl::tensor_grid< vec_t, vec_size_t >::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. However, this should probably be superceded by a more generic alternative which avoids explicit use of the 1-d interpolation types.
Member o2scl::tensor_grid< vec_t, vec_size_t >::set_grid_packed (const vec2_t &grid_vec)
Define a more generic interface for matrix types
Class o2scl::uniform_grid< data_t >
Implement operator==, etc?
Member o2scl::vector_integ_linear (size_t n, vec_t &x, vec2_t &y)
It might be faster to compute the sum directly rather than going through an o2scl::interp object .
Class o2scl_acol::acol_manager

Stack-like operations (push, pop, swap, stack-list, etc.)?

Use get_input() in comm_create?

Add functionality to ensure that three digit exponents are still handled gracefully (do this by creating a new boolean setting which, if true, always makes three spaces for exponents?)

Fix insert and insert_full so that it automatically renames columns

Allow "insert" commands to be restrictive, avoiding extrapolation

Replace ~ with $HOME in filenames (this might be best done inside the o2scl::cli class). (Some progress made. Function cli::expand_tilde() is written but not yet implemented.)

New 3d commands: transpose (for table3d), contours, find_grid_x, find_grid_y.

Class o2scl_hdf::hdf_file

This class opens all files in R/W mode, which may cause I/O problems in file systems. This needs to be fixed by allowing the user to open a read-only file.

The O2scl HDF functions do not always consistently choose between throwing O2scl exceptions and throwing HDF5 exceptions. Check and/or fix this.

Automatically close groups, e.g. by storing hid_t's in a stack?

Rewrite the _arr_alloc() functions so that they return a shared_ptr.

Move the code from the 'filelist' acol command here into hdf_file.

Member o2scl_hdf::hdf_file::get_szt_vec_copy (std::string name, vec_size_t &v)
This currently requires a copy, but there may be a way to write a new version which does not.
Member o2scl_hdf::hdf_file::getd_vec_copy (std::string name, vec_t &v)
This currently requires a copy, but there may be a way to write a new version which does not.
Member o2scl_hdf::hdf_file::geti_vec_copy (std::string name, vec_int_t &v)
This currently requires a copy, but there may be a way to write a new version which does not.
Member o2scl_linalg::HH_svx (size_t N, size_t M, mat_t &A, vec_t &x)
Handle memory allocation like the tridiagonal functions.
Class o2scl_linalg::lanczos< vec_t, mat_t >

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

Do something better than the simple matrix-vector product. For example, use dgemm() and allow user to specify column or row-major.

Rework memory allocation to perform as needed.

Class o2scl_linalg::linear_solver< vec_t, mat_t >
The test code uses a Hilbert matrix, which is known to be ill-conditioned, especially for the larger sizes. This should probably be changed.
Member o2scl_linalg::LU_decomp (const size_t N, mat_t &A, o2scl::permutation &p, int &signum)
The "swap rows j and i_pivot" section could probably be made more efficient using a "matrix_row"-like object as done in GSL. (7/16/09 - I've tried this, and it doesn't seem to improve the speed significantly.)
Member o2scl_linalg::LU_invert (const size_t N, const mat_t &LU, const o2scl::permutation &p, mat2_t &inverse)
Could rewrite to avoid mat_col_t, (9/16/09 - However, the function may be faster if mat_col_t is left in, so it's unclear what's best.)
Member o2scl_linalg::solve_cyc_tridiag_nonsym (const vec_t &diag, const vec2_t &abovediag, const vec3_t &belowdiag, const vec4_t &rhs, vec5_t &x, size_t N, mem_t &m)
Offer an option to avoid throwing on divide by zero?
Member o2scl_linalg::solve_tridiag_nonsym (const vec_t &diag, const vec2_t &abovediag, const vec3_t &belowdiag, const vec4_t &rhs, vec5_t &x, size_t N, mem_t &m)
Offer an option to avoid throwing on divide by zero?
Member o2scl_linalg::SV_decomp_jacobi (size_t M, size_t N, mat_t &A, mat2_t &Q, vec_t &S)
There were originally a few GSL_COERCE_DBL calls which have been temporarily removed and could be restored.
File poly.h
The quartics are tested only for a4=1, which should probably be generalized.
File vec_stats.h
Consider generalizing to other data types.
File vector.h

Create a matrix transpose copy function?

Create matrix swap row and column functions

Documentation generated with Doxygen. Provided under the GNU Free Documentation License (see License Information).