Todo List

Member _InternalSourcePosition::PosRangeString (const SourcePosition &end, bool with_file=1) const

#warning "This may handle cases with line/lpos<0 incorrectly."

Member VM::AssemblerFile_Plaintext::_ParseVarType (const TextAsmScanner::Token::Type *t)

FIXME VM: TypeID not needed in pointer type (i.e. p>TYPEID).

Member ExecutionThread::start ()

Thread creation failure error reporting. (really do it?)

Class InternalRefNodeBase

ref counting: fix "a=a;" issue.

Member LinkedList::MergeSort (const OP &_OP)

MergeSort: This could be optimized (count elems once, not in MiddleNode(), (de)queuing overhead...). FIXME!!!

Member MessageManager::~MessageManager ()

Should we do that - or delete the handlers?

Member ModulePool::pool

fixme (stdio.h)

Class NUM::NoiseGenerator_Base< T >

Add support for different random number generators. (later!!)

Class NUM::OMatrix< T >

Write a ref-counting version (like TLString) and see if it is faster. (To be done when the application actually works.)

Member NUM::OMatrix::OMatrix (enum _Rotate, const Vector3< T > &axis, T angle)

test this; maybe the matrix needs transposing.
IIRC, the invariant angle for rotations can be calclated as
omega = 1/2*(R - R^t) --> x in R^3
where the mapping is
x[0] = omega[0][1], x[1] = -omega[0][2], x[2] = omega[1][2].

Member NUM::Plane3::normalize ()

also update dist?

Member NUM::PolyRootSolver_Sturm::solve (int order, const dbl *c, dbl *r)

fix sturm root solver: brackets / borders!

#warning THIS IS FLAWED...

Class NUM::RandomNumberGenerator

This class waits to be implemented. STOP! Don't do it yet!

Class NUM::RandomNumberGenerator_Base

should add method to query information (name, period)

Member SError::_assign (GError *&g)

how to set the domain?

Member SourcePositionArchive::AllocISF (const TLString &path, SourceFileNode &parent)

remove stdio.h (only needed for debug).

Member SourcePositionCache::find (int line, int lpos)

remove stdio.h (only needed for debug).

Member TLArrayHeap::_ReHeap (size_t idx, int size_change=0)

#warning "Optimize me..."

Class TLLinearQueue< T, _OP >

(tllinearqueue.h) Untested code.

Member TLLinearQueue::clear ()

tllinearqueue.h:clear: This could be made more efficient. (especially if OP.pdt==0)

Class TLLinearQueue< T, _OP >::Iterator

FIXME: Get proper interface for iterator.

Class TLSortedArray< T, _OP >

#warning "tlsortedarray.h: Completely untested code."

Member TLSortedArray::ReOrder ()

Could use binary search for insert position but ONLY for elems which are out of order! (Otherwise no longer O(m*n)).

Member TLString::find (const char *str) const

Implement fancy Boyer-Moore searching for longer strings :)

Member TLString::ParseString (const char *instr, ssize_t inlen, SError &error)

ParseString(): Improve error handling (accumulation of errors); also remove some comments about fixed bugs...

Member TLString::SData::_EnsureSize (size_t s)

Most of the functions using _detach() could be optimized since they will first create a copy of the string which is then modified.

Must check this again for thread-safetyness. All the lines "Aquire a refernce so that it will not be modified" are probably not necessary!

Maybe get rid of all that code duplication. But OTOH, things are currently more easily readable.

Go fancy and implement O(n/m) avg, O(n) worst Boyer-Moore for find().

Member NUM::Vector3::Vector3 ()

Implement faster version with vector support (SSE,...); see gcc-info: vector_size, V4SI, __builtin_ia32_addsubpd

Member VM::VMLinker::_MergeNamespaceInfo_Recursive (NamespaceInfo **head_list, uint nheads)

_MergeNamespaceInfo_Recursive(): Possible speedup if we memorize which d->membvar[] have

linker.cc: Could use local stack allocation ala alloca() or char buf[n] if supported. See GMP for similar implementation.

Member ParseCharacterSpec (const char *str, SError &error)

ParseCharacterSpec() to be implemented.

Member ParseFloatSpec (const char *str, ParsedFloatValue *sf, SError &error)

Should we use HUGE_VALF or FLT_MAX?

Member ParseIntegerSpec (const char *str, ParsedIntegerValue *si, SError &error)

ParseIntegerSpec() to be implemented.

Member PolyRootSolver_Sturm_BufOnStack

See what is faster: As with alloc debugging enabled, the first version (stack) is obviously faster; this probably also holds for non-alloc debugging. 1 -> alloc coeff buffer on stack (a bit too much is allocated) 0 -> alloc coeff buffer via ALLOC<>.

Member _AllocFailure (size_t size)

use an exception or portable error reporting mechanisms.

Member _DUMMY_FUNCION_lib_threadlibrary_atomic_h ()

Can be removed once the system is running.

Member _DUMMY_FUNCION_lib_threadlibrary_rwlock_h ()

Can be removed once the system is running.

Member _DUMMY_FUNCION_lib_threadlibrary_threadkey_h ()

Can be removed once the system is running.

Member _SortSwap (T *a, size_t i0, size_t i1, T &tmp, const _OP &op)

#warning "sort: Stability of insertion sort not tested."

Member CleverQuickSort (T *a, size_t nelem, size_t insertion_sort_thresh=16, const _OP &op=TLDefaultOperators_CDT< T >())

Possible improvement for clever quick sort: introsort: use heapsort when runtime becomes quadratic (i.e. recursion depth >> log(nelem)).

Member CountBitsCleared (T x)

Make it work faster (CountBitsCleared; see ...Set()).

Member CountBitsSet (T x)

Make it work faster (CountBitsSet; see function). Use __builtin_popcount,l,ll(x) if available (although "only" equally-fast in i386).

Member SearchFirstClearedBit (T x)

Make it work faster (SearchFirstClearedBit).

Member SearchFirstSetBit (T x)

Make it work faster (SearchFirstSetBit). Could use a binary-search based method with logarithmic runtime but be careful with MSBfirst vs. LSBfirst.

Namespace NUM

(num_math) Go through the source and check where we can use potentially faster functions, especially is_negative(), fma().
Also, get rid of NAN and Inf and use FPConst<>::nan,... instead.
Furthermore, add the following functions from glibc and provide own implementation if unavailable: erf, erfc, lgamma_r, tgamma.
Go through the source and see if we want to do rounding instead of using int(x+0.5).
Things still missing: int feclearexcept(int excepts); int fegetexceptflag(fexcept_t *flagp, int excepts); int feraiseexcept(int excepts); int fesetexceptflag(const fexcept_t *flagp, int excepts); int fetestexcept(int excepts); int fegetround(void); int fesetround(int rounding_mode); int fegetenv(fenv_t *envp); int feholdexcept(fenv_t *envp); int fesetenv(const fenv_t *envp); int feupdateenv(const fenv_t *envp);
As well as:
nextafter(), nexttoward(),..
HAVE a look at GCC's "other built-in functions": Also for bit-counting,

Member NUM::IntersectTriangle (const Vector3< T > &orig, const Vector3< T > &dir, const Vector3< V > &vert0, const Vector3< V > &vert1, const Vector3< V > &vert2, T *t, T *u, T *v)

Add a header file for IntersectTriangle() code...

Member NUM::IntersectTriangle (const Vector3< T > &orig, const Vector3< T > &dir, const Vector3< V > &vert0, const Vector3< V > &vert1, const Vector3< V > &vert2, T *t, T *u, T *v)

What to do with this epsilon value...

Member NUM::StepCubic (T x, T a, T b)

faster version for symmetric borders?

Member NUM::StepLinear (T x, T a, T b)

faster version for symmetric borders?

---