You can subscribe to this list here.
2001 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}
(4) 
_{Dec}
(6) 

2002 
_{Jan}
(68) 
_{Feb}
(72) 
_{Mar}
(46) 
_{Apr}
(44) 
_{May}
(40) 
_{Jun}
(54) 
_{Jul}
(26) 
_{Aug}
(86) 
_{Sep}
(95) 
_{Oct}
(151) 
_{Nov}
(65) 
_{Dec}
(34) 
2003 
_{Jan}
(22) 
_{Feb}
(70) 
_{Mar}
(24) 
_{Apr}
(28) 
_{May}
(50) 
_{Jun}
(31) 
_{Jul}
(17) 
_{Aug}
(42) 
_{Sep}
(27) 
_{Oct}
(71) 
_{Nov}
(27) 
_{Dec}
(71) 
2004 
_{Jan}
(40) 
_{Feb}
(30) 
_{Mar}
(20) 
_{Apr}
(22) 
_{May}
(41) 
_{Jun}
(9) 
_{Jul}
(24) 
_{Aug}
(41) 
_{Sep}
(35) 
_{Oct}
(8) 
_{Nov}
(5) 
_{Dec}
(4) 
2005 
_{Jan}
(27) 
_{Feb}
(13) 
_{Mar}
(18) 
_{Apr}
(7) 
_{May}
(10) 
_{Jun}
(36) 
_{Jul}
(28) 
_{Aug}
(17) 
_{Sep}
(1) 
_{Oct}
(11) 
_{Nov}
(12) 
_{Dec}
(15) 
2006 
_{Jan}
(99) 
_{Feb}
(5) 
_{Mar}
(31) 
_{Apr}
(26) 
_{May}
(20) 
_{Jun}
(33) 
_{Jul}
(45) 
_{Aug}
(18) 
_{Sep}
(2) 
_{Oct}
(19) 
_{Nov}
(3) 
_{Dec}
(8) 
2007 
_{Jan}
(1) 
_{Feb}
(15) 
_{Mar}
(20) 
_{Apr}

_{May}
(4) 
_{Jun}
(6) 
_{Jul}
(11) 
_{Aug}
(11) 
_{Sep}
(11) 
_{Oct}
(19) 
_{Nov}
(25) 
_{Dec}
(46) 
2008 
_{Jan}
(42) 
_{Feb}
(20) 
_{Mar}
(43) 
_{Apr}
(24) 
_{May}
(4) 
_{Jun}

_{Jul}
(19) 
_{Aug}
(63) 
_{Sep}
(33) 
_{Oct}
(17) 
_{Nov}
(36) 
_{Dec}
(20) 
2009 
_{Jan}
(36) 
_{Feb}
(18) 
_{Mar}
(144) 
_{Apr}
(36) 
_{May}
(11) 
_{Jun}
(7) 
_{Jul}
(8) 
_{Aug}
(21) 
_{Sep}
(33) 
_{Oct}
(7) 
_{Nov}
(2) 
_{Dec}
(1) 
2010 
_{Jan}
(33) 
_{Feb}
(3) 
_{Mar}
(34) 
_{Apr}
(2) 
_{May}
(1) 
_{Jun}
(2) 
_{Jul}
(3) 
_{Aug}
(28) 
_{Sep}
(8) 
_{Oct}
(12) 
_{Nov}
(11) 
_{Dec}
(44) 
2011 
_{Jan}
(30) 
_{Feb}
(10) 
_{Mar}
(8) 
_{Apr}
(23) 
_{May}
(8) 
_{Jun}
(9) 
_{Jul}
(3) 
_{Aug}
(9) 
_{Sep}
(5) 
_{Oct}
(9) 
_{Nov}
(11) 
_{Dec}
(24) 
2012 
_{Jan}
(6) 
_{Feb}
(32) 
_{Mar}
(8) 
_{Apr}
(26) 
_{May}
(13) 
_{Jun}
(51) 
_{Jul}
(21) 
_{Aug}
(7) 
_{Sep}
(9) 
_{Oct}
(13) 
_{Nov}
(5) 
_{Dec}
(10) 
2013 
_{Jan}
(56) 
_{Feb}
(6) 
_{Mar}
(15) 
_{Apr}
(4) 
_{May}
(24) 
_{Jun}
(4) 
_{Jul}
(9) 
_{Aug}

_{Sep}

_{Oct}
(2) 
_{Nov}
(1) 
_{Dec}
(8) 
2014 
_{Jan}
(7) 
_{Feb}

_{Mar}

_{Apr}

_{May}
(12) 
_{Jun}
(3) 
_{Jul}
(7) 
_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}
(19) 
2015 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}
(1) 
_{Aug}

_{Sep}

_{Oct}

_{Nov}
(22) 
_{Dec}
(25) 
2016 
_{Jan}
(9) 
_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

S  M  T  W  T  F  S 







1

2

3
(1) 
4
(8) 
5

6
(2) 
7
(1) 
8

9

10

11

12
(4) 
13
(1) 
14

15

16

17

18
(3) 
19
(12) 
20
(9) 
21
(6) 
22
(1) 
23

24
(5) 
25
(2) 
26
(6) 
27
(3) 
28
(6) 

From: Amitha Perera <perera@cs...>  20030225 21:05:27

On Tue 25 Feb 2003, Paul Smyth wrote: > I had written an number of functions which perform operations on fixed size > vectors and matrices, and which took vector_fixed_ref and matrix_fixed_refs > as arguments. (As vector_fixed was derived from vector_fixed_ref, these > functions could operate on vector_fixed also). > Now that the two fixedsize classes have been taken out of the heirarchy, it > is now difficult/impossible to use a vector_fixed as a vector_fixed > ref. Yes. :( > e.g. > T my_dot_product(const vnl_vector_fixed_ref<T,n> & a ,const > vnl_vector_fixed_ref<T,n> & b) > void f() > { > vnl_vector_fixed<double,3> a,b; > double d = my_dot_product(a,b); > } > now doesn't compile. However, double d = my_dot_product( a.as_ref(), b.as_ref() ); should compile. Actually, you would need to implement as_fixed_ref() to do exactly what you want. > 1) Am I being reasonable wanting this behaviour? I think it is reasonable to ask for a vnl_vector_fixed_ref<T,n>. However, it is not clear what that entails, as I write below. > 2) What can I do to get this behaviour again? You would probably need to implement a separate class. See below. > 3) I'd like to make these fixedref classes standalone/lightweight, and no > longer derived from vnl_vector_ref etc. for speed/inlining & simplicity. Is > that mad? N.B. They are currently derived from vnl_vector_ref<T>, > vnl_matrix_ref<T> I think they would pretty much have to be. > I've tried adding "operator vnl_vector_fixed_ref<T,n>()" to vnl_vector_fixed > to do automatic casts. These don't seem to work, at least under > MSCV6. Unfortunately, userdefined conversion operators are not used when calling templated functions, so the only "conversion" that can happen is a derived>base conversion. Hence the need for vnl_vector_fixed::as_ref(). (Look at the documentation there.) > Obviously, one could make vnl_vector_fixed_ref a base class to > vnl_vector_fixed, at the cost of adding sizeof(T*) to the size of > vnl_vector_fixed. I presume this is not desirable, given the amout of > trouble that was gone to in order to minimise > sizeof(vnl_vector_fixed). The whole point of the change was to avoid the extra sizeof(T*) storage. In particular, the ITK community would like to store collections of millions of these, so every byte counts. > Lots of built in algorithms in vnl_matrix_fixed.h that currently operate on > vnl_matrix_fixed or vnl_vector_fixed might operate on fixed size reference > types instead. Do people care about this at all? I do, but I don't have the time to fix it correctly. My thoughts on the design:  vnl_vector_fixed<T,n> must be exactly sizeof(T)*n bytes. This means that there is no way for it to masquerade as a vnl_vector_fixed_ref<T,n>.  We can get a slightly better design by implementing a policybased vector. Brad King at Kitware suggested some things along this line when he and I were discussing the changes the vnl, but it didn't pan out. I have some newer ideas that may make it work. The biggest drawback is functions that used to use vnl_vector_fixed<T,n> would now need to use vnl_vector_fixed<T,n,AllocationPolicy> Something like template<class T, unsigned n, class Policy> vnl_vector_fixed_general { ... }; template<class T, unsigned n> vnl_vector_fixed : public vnl_vector_fixed_general<T,n,LocalSpace> {...}; template<class T, unsigned n> vnl_vector_fixed_ref : public vnl_vector_fixed_general<T,n,ExternalSpace> {...}; may make the transistion easier. Actually, template<class T, unsigned n, class Policy=LocalSpace> vnl_vector_fixed {...}; may work and be automatically backward compatible.  The best solution is probably to have a vnl_vector<T,Policy> and a vnl_vector<T,n,Policy>, with derived classes for backward compatibility. All the functions in vnl should be templated over the policy.  Using a policy template parameter may create practical problems, though, because compilers are broken. For example, witness the current hacks in vnl_matrix_fixed.h to get matrixmatrix multiplication working for fixed matrices in VC6. Amitha. 
From: Paul Smyth <paul.smyth@vi...>  20030225 19:52:28

Hi, We now have matrix_fixed and vector_fixed which are spaceefficient (thanks to Amitha), together with operators, or conversion functions to make a vnl_matrix or vnl_vector. I had written an number of functions which perform operations on fixed size vectors and matrices, and which took vector_fixed_ref and matrix_fixed_refs as arguments. (As vector_fixed was derived from vector_fixed_ref, these functions could operate on vector_fixed also). Now that the two fixedsize classes have been taken out of the heirarchy, it is now difficult/impossible to use a vector_fixed as a vector_fixed ref. e.g. T my_dot_product(const vnl_vector_fixed_ref<T,n> & a ,const vnl_vector_fixed_ref<T,n> & b) void f() { vnl_vector_fixed<double,3> a,b; double d = my_dot_product(a,b); } now doesn't compile. My questions are: 0) Did anyone else ever use the fixedref classes? 1) Am I being reasonable wanting this behaviour? 2) What can I do to get this behaviour again? 3) I'd like to make these fixedref classes standalone/lightweight, and no longer derived from vnl_vector_ref etc. for speed/inlining & simplicity. Is that mad? N.B. They are currently derived from vnl_vector_ref<T>, vnl_matrix_ref<T> The problem is pretty much the same for vnl_matrix_fixed_ref and vnl_vector_fixed_ref, so let's consider vnl_vector_fixed_ref. I've tried adding "operator vnl_vector_fixed_ref<T,n>()" to vnl_vector_fixed to do automatic casts. These don't seem to work, at least under MSCV6. Obviously, one could make vnl_vector_fixed_ref a base class to vnl_vector_fixed, at the cost of adding sizeof(T*) to the size of vnl_vector_fixed. I presume this is not desirable, given the amout of trouble that was gone to in order to minimise sizeof(vnl_vector_fixed). Other issues: Lots of built in algorithms in vnl_matrix_fixed.h that currently operate on vnl_matrix_fixed or vnl_vector_fixed might operate on fixed size reference types instead. Do people care about this at all? Any advice gratefully received. Paul. This email, and any attachment, is confidential. If you have received it in error, please delete it from your system, do not use or disclose the information in any way, and notify me immediately. 