- Class anneal_mt< param_t, param_vec_t, func_t, vec_t, alloc_vec_t, alloc_t, rng_t >
- There may be a good way to remove the function indirection here to make this class a bit faster.
- File array.h
- Create a class which views a C-style array as a matrix and offers an
operator(,)
- Class array_alloc< vec_t >
- Might it be possible to rework this so that it does range checking and ensures that the user doesn't try to allocate more or less space? I.e. array_alloc<double[2]> complains if you try an allocate(x,3)?
- Class array_const_subvector
- Make the member data truly const and remove the extra typecast.
- Class bin_size
- Finish this.
- 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 [].
- Class cern_adapt< func_t, nsub >
- Allow user to set the initial subdivisions?
- It might be interesting to directly compare the performance of this class to gsl_inte_qag .
- There is a fixme entry in the code which could be resolved.
- Output the point where most subdividing was required?
- Class cern_deriv< func_t >
All of the coefficients appear to be fractions which could be replaced with exact representation?
Record the number of function calls?
- Class cern_gauss< func_t >
- Allow user to change
cst
?
- Class cern_mroot< func_t, vec_t, alloc_vec_t, alloc_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 cern_mroot_root< func_t >
- Double-check this class to make sure it cannot fail while returning 0 for success.
- Global cern_mroot_root< func_t >::eps
- This number should probably default to one of the GSL tolerances.
- Class 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 cli::par_list in order to ensure parameter names do not contain whitespace
- Global 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)
- Class 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.
- Class comp_gen_inte< func_t, lfunc_t, ufunc_t, vec_t, alloc_vec_t, alloc_t >
- Provide an example of usage for this class.
- Class composite_inte< func_t, vec_t, alloc_vec_t, alloc_t >
- Create a function to set an entire array of one-dimensional integration objects at once
- Class contour
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.
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.
- Global contour::get_data (size_t &sizex, size_t &sizey, ovector *&x_fun, ovector *&y_fun, omatrix *&udata)
- There is probably a better way than returning pointers to the internal data.
- Class contour_line
Write HDF I/O for contour lines?
Make this a subclass of contour .
- Class convert_units
- Ideally, a real C++ API for the GNU units command would be better.
- File cx_arith.h
- Define operators with assignment for complex + double?
- Class deriv< func_t >
- Improve the methods for second and third derivatives
- Class edge_crossings
Write HDF I/O object for edge crossings
Make this a subclass of contour .
- Class eqi_deriv< func_t, vec_t >
- Finish the second and third derivative formulas.
- Class err_hnd_type
- There may be an issue associated with the string manipulations causing errors in the error handler.
- Class expect_val
- If
n_per_block
is nonzero and the user adds more than n_blocks
times n_per_block
data, set n_per_block
to zero, allocate the last
structure and fall back to the variable block size method.
- Page File I/O with HDF5
- Create an HDF file I/O example.
- Class format_float
Handle inf's and nan's correctly.
Allow change of string for the "+" sign for the exponent
- Class gen_inte< func_t, lfunc_t, ufunc_t, vec_t >
- It might be interesting to construct a child class of gen_inte which automatically transforms variables to a hypercube and then applies a child of multi_inte to do the integration.
- Class gen_test_number< tot >
- Document what happens if
tot
is pathologically small.
- Class gradient< func_t, vec_t >
- Consider making an exact_grad class for computing exact gradients.
- Class gsl_anneal< func_t, vec_t, alloc_vec_t, alloc_t, rng_t >
There's x0, old_x, new_x, best_x, and x? There's probably some duplication here which could be avoided.
- Implement a more general simulated annealing routine which would allow the solution of discrete problems like the Traveling Salesman problem.
- Class gsl_astep< func_t, vec_t, alloc_vec_t, alloc_t >
- Compare more directly to GSL
- Class gsl_bsimp< func_t, jac_func_t, vec_t, alloc_vec_t, alloc_t, mat_t, alloc_mat_t, mat_alloc_t >
Create an example with a stiff diff eq. which requires this kind of stepper
More detailed documentation about the algorithm
Figure out if this should be a child of ode_step or adapt_step. 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 as uvectors?
Rework linear solver to be amenable to using a sparse matrix solver
- Global gsl_cubic_real_coeff::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 gsl_deriv< func_t >
- Include the forward and backward GSL derivatives?
- Class gsl_inte_kronrod< func_t >
- Convert 'double *' objects to uvector
- Global gsl_inte_kronrod< 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 inte.
- Class gsl_inte_qag< 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.
- Global gsl_inte_qag< 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 gsl_inte_qawc< func_t >
- 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_qawo_sin< func_t >::qawo (func_t &func, const double a, const double epsabs, const double epsrel, gsl_inte_workspace *loc_w, gsl_integration_qawo_table *wf, double *result, double *abserr)
- Remove goto statements.
- Class gsl_inte_singular< func_t >
- Some of the functions inside this class could be moved out of header files?
- Global gsl_inte_singular< func_t >::extrap_table
- Move this to a new class, with qelg() as a method
- Global gsl_inte_singular< func_t >::extrap_table
- Move this to a new class, with qelg() as a method
- Global gsl_inte_singular< 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.
- Global gsl_min_brent< 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 gsl_min_quad_golden< func_t >
- Take common elements of this and gsl_min_brent and move to a generic GSL minimizer type?
- Global gsl_miser< func_t, rng_t, vec_t, alloc_vec_t, alloc_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 uvector &lxmid, uvector &lsigma_l, uvector &lsigma_r)
- Remove the reference to GSL_POSINF and replace with a function parameter.
- Class gsl_mmin_simp2< func_t, vec_t, alloc_vec_t, alloc_t >
- Double check that the updates in gsl-1.13 are included here, and also add support for the nmsimplex2rand algorithm in GSL.
- Class gsl_mroot_hybrids< func_t, vec_t, alloc_vec_t, alloc_t, mat_t, alloc_mat_t, mat_alloc_t, jfunc_t >
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?
It might be good to make sure that we're directly testing to make sure that GSL and O2SCL are more or less identical.
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.
- Class gsl_quartic_real
- Optimize value of
cube_root_tol
and compare more clearly to gsl_quartic_real2
- Class gsl_quartic_real2
- Optimize value of
cube_root_tol
and compare more clearly to gsl_quartic_real
- Class gsl_root_brent< 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 gsl_root_brent::test_form.
- Class gsl_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 gsl_mroot_hybrids.
- Class gsl_series
- Move the worspaces to classes?
- Class gsl_smooth
Generalize to generic vector types. (Does this require reworking the GSL linear fitting routines?) In the meantime, make a ovector interface.
Possibly create a new gsl_bspline class which replaces the GSL bspline workspace
Allow user to probe chi squared and the covariance?
- Class gsl_vegas< func_t, rng_t, vec_t, alloc_vec_t, alloc_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.
- Class hdf_file
- Automatically close groups, e.g. by storing hid_t's in a stack?
- Class hist
Would be nice not to have to create a new search_vec object in get_bin_index().
Consider adding the analogs of the GSL histogram sampling functions
Add a function which computes the bin sizes?
- Class 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.
- Global hybrids_base::compute_df (size_t n, const vec2_t &ff_trial, const vec2_t &fl, ovector_base &dfl)
- Replace with daxpy?
- Global 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.
- Global hybrids_base::compute_trial_step (size_t N, vec2_t &xl, vec2_t &dxl, vec2_t &xx_trial)
- Replace with daxpy.
- Global hybrids_base::enorm (size_t N, const vec2_t &ff)
- Replace this with
dnrm2
from cblas_base.h
- Class 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 lanczos< vec_t, mat_t, alloc_vec_t, alloc_t >
The function eigen_tdiag() automatically sorts the eigenvalues, which may not be necessary.
Do something better than the naive matrix-vector product. For example, use dgemm() and allow user to specify column or row-major.
Rework memory allocation to perform as needed.
- Global matrix_cx_copy_gsl (size_t M, size_t N, mat_t &src, mat2_t &dest)
- At present this works only with complex types based directly on the GSL complex format. This could be improved.
- Global matrix_max (size_t n, const size_t m, const mat_t &data)
- Write matrix_max_index() and related functions similar to the way vector_max_index() works.
- Global matrix_out (std::ostream &os, mat_t &A, size_t nrows, size_t ncols)
- If all of the matrix elements are positive integers and scientific mode is not set, then we can avoid printing the extra spaces.
- Class matrix_row< mat_t >
- Generalize to operator(,)
- Page Minimization
- Plot the spring function
- Class minimize< func_t, dfunc_t >
- Add a class for the quad_golden algorithm from GSL.
- Global minimize< 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?
- Class minimize_de< func_t, dfunc_t >
- Create a version of gsl_mmin_conf which implements a minimizer with this interface.
- Class mroot< func_t, vec_t, jfunc_t >
- Change ntrial to size_t?
- Global O2SCL_ASSERT (ev)
- Make this consistent with assert() using NDEBUG?
- Global o2scl_graph::new_graph_ticks (TCanvas *&c1, TPad *&p1, TH1 *&th1, std::string CanvasName, std::string WindowName, std::string PadName, double lleft, double lbottom, double lright, double ltop, TGaxis *&a1, TGaxis *&a2, int left=0, int top=0, int right=700, int bottom=700, bool logx=false, bool logy=false)
- Modify this to just directly call new_graph() and add the new axes on top.
- Namespace o2scl_linalg
- Move this documentation to the linalg directory.
- Global 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::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.
- Global 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.)
- Global 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.)
- Global 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?
- Global 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?
- Class ode_bv_mshoot< func_t, mat_t, vec_t, alloc_vec_t, alloc_t, vec_int_t >
- Make a class which performs an iterative linear solver which uses sparse matrices like ode_it_solve?
- Class ode_it_solve< func_t, vec_t, mat_t, matrix_row_t, solver_vec_t, solver_mat_t >
Create a GSL-like set() and iterate() interface
Implement as a child of ode_bv_solve ?
Max and average tolerance?
- Class ode_iv_solve< func_t, vec_t, alloc_vec_t, alloc_t >
- The form of solve_final_value() is very similar to that of adapt_step::astep_full(), but not quite the same. Maybe should probably be made to be consistent with each other?
- Global ode_iv_solve< func_t, vec_t, alloc_vec_t, alloc_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.
- Global ode_iv_solve< func_t, vec_t, alloc_vec_t, alloc_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 ofvector< N >
- Consider making allocate() and free() functions private for this class?
- Class omatrix_col_tlate< data_t, mparent_t, vparent_t, block_t >
- Also do a umatrix constructor since we can't do that with uvectors
- File omatrix_tlate.h
- The
xmatrix
class demonstrates how operator[] could return an ovector_array object and thus provide more bounds-checking. This would demand including a new parameter in omatrix_view_tlate which contains the vector type.
- Class ool_constr_mmin< func_t, dfunc_t, hfunc_t, vec_t, alloc_vec_t, alloc_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 ool_mmin_pgrad< func_t, dfunc_t, vec_t, alloc_vec_t, alloc_t >
Replace the explicit norm computation below with the more accurate dnrm2 from linalg
Replace the generic variable 'tol' with 'tolf' or 'tolx' from multi_min.
- Class ool_mmin_spg< func_t, dfunc_t, vec_t, alloc_vec_t, alloc_t >
- There is some memory allocation which isn't deallocated until the destructor, and should be handled a bit more elegantly.
- Global operator<< (std::ostream &os, const umatrix_cx_view_tlate< data_t, complex_t > &v)
- Make this function work even when scientific mode is not on, either by converting to scientific mode and converting back, or by leaving scientific mode off and padding with spaces
- Global operator<< (std::ostream &os, const umatrix_const_view_tlate< data_t > &v)
- This assumes that scientific mode is on and showpos is off. It'd be nice to fix this.
- Global operator<< (std::ostream &os, const omatrix_const_view_tlate< data_t, parent_t, block_t > &v)
- This assumes that scientific mode is on and showpos is off. It'd be nice to fix this.
- Class other_todos_and_bugs
- Make sure we have a uvector_cx_alloc, ovector_cx_const_reverse, ovector_cx_const_subvector_reverse, uvector_reverse, uvector_const_reverse, uvector_subvector_reverse, uvector_const_subvector_reverse, omatrix_cx_diag, blah_const_diag, umatrix_diag, and umatrix_cx_diag
- ovector_cx_view::operator=(uvector_cx_view &) is missing
- ovector_cx::operator=(uvector_cx_view &) is missing
- uvector_c_view::operator+=(complex) is missing
- uvector_c_view::operator-=(complex) is missing
- uvector_c_view::operator*=(complex) is missing
Currently, I believe the testing code requires the shared libraries and may not work if the static libraries only are installed. It would be nice to ensure the tests could be complied in either case.
- Class ovector_alloc
- Could (or should?) the allocate() functions be adapted to return an integer error value?
- Class ovector_const_reverse_tlate< data_t, vparent_t, block_t >
- I think that maybe in order to ensure that this isn't created from an already reversed vector, this class has to be separated from the hierarchy altogether. However, I think this might break the smart interpolation stuff.
- File ovector_tlate.h
Clean up maybe by moving, for example, ovector reverse classes to a different header file
Define ovector_uint classes?
- Class pinside
- The inside() functions actually copy the points twice. This can be made more efficient.
- Class planar_intp< vec_t, mat_t >
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. (11/1/11 - Maybe not. We might be able to get away with just storing an vector which records the index j of the point in the data set which is the nearest neighbor for each point i in the data set.)
Instead of comparing den
with zero, add the option of comparing it with a small number.
Allow the user to specify the scales used for x and y, instead of computing max-min every time.
The generalization to more dimensions might be straight forward.
- Class pointer_2d_alloc< base_t >
- There may be a slight issue here if the pointer allocation succeeds and the list insertion fails, and the user catches the exception thrown by the list insertion failure, then a memory leak will ensue. This might be partially ameliorated by counting allocations and insertions. This failure mechanism is rarely encountered in practice.
- Class pointer_alloc< base_t >
- There may be a slight issue here if the pointer allocation succeeds and the list insertion fails, and the user catches the exception thrown by the list insertion failure, then a memory leak will ensue. This might be partially ameliorated by counting allocations and insertions. This failure mechanism is rarely encountered in practice.
- File poly.h
- The quartics are tested only for a4=1, which should probably be generalized.
- Class polylog
- Give error estimate?
- Improve accuracy?
- Use more sophisticated interpolation?
- Add the series
for
?
- Implement for positive arguments < 1.0
- Make another polylog class which implements series acceleration?
- Global quadratic_extremum_x (double x1, double x2, double x3, double y1, double y2, double y3)
Make a function quadratic_points(double x1, double x2, double x3, double y1, double y2, double y3, double &a, double &b, double &c)?
Make a quadratic_extremum_xy()?
- Class rnga
- Consider some analog of the GSL function
gsl_rng_uniform_pos()
, i.e. as used in the GSL Monte Carlo classes.
- Global rnga::clock_seed ()
- Figure out a better way of computing a random seed in a platform-independent way.
- Class root< func_t, dfunc_t >
- Maybe consider allowing the user to specify the stream to which 'verbose' information is sent.
- Class root_de< func_t, dfunc_t >
- At the moment, the functions solve() and solve_bkt() are not implemented for derivative solvers.
- Global scalar_ev::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.
- Class search_vec< vec_t >
- Consider a sanity check to ensure that the cache is never larger than the vector length.
- Global 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.
- Global search_vec_ext< vec_t >::search_vec_ext (size_t nn, vec_t &x)
- This could be rewritten to allow vectors with only one element (5/2/11: It looks like this might have been done already?)
- Class smart_interp_vec< vec_t, svec_t, alloc_vec_t, alloc_t >
- Properly implement handling of non-monotonic regions in the derivative functions as well as the interpolation function.
- Class table
- Rewrite the table::create_array() and table::insert_data() functions for generic vector type
- Return the empty column in the operator[] functions as is done for the get_column() functions.
- A "delete rows" method to delete a range of several rows
- 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 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()?
- Class table_units
- Make table methods virtual? (not necessary yet since delete_column() isn't referred to internally)
- Class tensor
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.
- Class tensor_grid
Only allocate space for grid if it is set
Could implement arithmetic operators + and - and some different products.
Consider creating a set_grid() function which takes grids from an object like hist_grid. Maybe make a constructor for a tensor_grid object which just takes as input a set of grids?
- Global tensor_grid::interpolate (double *vals)
Maybe make this a template as well?
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.
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.
- Global tensor_grid::set_grid (const vec_t &grid_vec)
- Define a more generic interface for matrix types
- Class tensor_old
Could implement arithmetic operators + and - and some different products.
Implement copies to and from vector and matrices
Implement tensor_old contractions, i.e. tensor_old = tensor_old * tensor_old
Consider making a template type to replace double, e.g. value_t
.
Could be interesting to write an iterator for this class.
- Class tensor_old_grid
Only allocate space for grid if it is set
Could implement arithmetic operators + and - and some different products.
Consider creating a set_grid() function which takes grids from an object like hist_grid. Maybe make a constructor for a tensor_old_grid object which just takes as input a set of grids?
- Global tensor_old_grid::interpolate (double *vals)
Maybe make this a template as well?
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_old. However, this should probably be superceded by a more generic alternative which avoids explicit use of the 1-d interpolation types.
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_old. However, this should probably be superceded by a more generic alternative which avoids explicit use of the 1-d interpolation types.
- Global tensor_old_grid::set_grid (const vec_t &grid)
- Define a more generic interface for matrix types
- 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.
Implement an improved caching system in case, for example xfirst
is true and the last interpolation used the same value of x
.
- Class uvector_const_view_tlate< data_t >
- Could allow user-defined specification of restrict keyword
- Class uvector_cx_view_tlate< data_t, complex_t >
- Write lookup() method, and possibly an erase() method.
- File vec_arith.h
Define operators for complex vector * real matrix
Define == and != for complex vectors
These should be replaced by the BLAS routines where possible?
- 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
- Global vector_cx_copy_gsl (size_t N, vec_t &src, vec2_t &dest)
- At present this works only with complex types based directly on the GSL complex format. This could be improved.
- Global vector_lookup (size_t n, const vec_t &x, double x0)
- Write matrix_lookup().