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}

S  M  T  W  T  F  S 






1
(1) 
2
(2) 
3
(3) 
4

5
(6) 
6
(4) 
7
(5) 
8

9

10

11
(1) 
12
(1) 
13
(10) 
14
(10) 
15
(4) 
16

17

18
(2) 
19
(4) 
20
(1) 
21
(2) 
22

23

24

25

26

27

28
(2) 
29
(4) 
30
(1) 
31







From: Peter Vanroose <peter_vanroose@ya...>  20080805 17:56:08

OK  added the straightforward nonoptimized inlined vnl_math_floor() and vnl_math_ceil() to vnl_math.h and added appropriate tests to vnl/tests/test_math.cxx . I won't attempt to implement the gcc and msvc optimized versions  that's for the specialists who have speed tests to compare and finetune the implementations.  Peter. __________________________________________________________ Går det långsamt? Skaffa dig en snabbare bredbandsuppkoppling. Sök och jämför priser hos Kelkoo. http://www.kelkoo.se/c100015813bredband.html?partnerId=96914325 
From: Tom Vercauteren <tom.vercauteren@m4...>  20080805 12:42:53

> I've been using http://www.stereopsis.com/FPU.html and its references as a > guide. I have been trying (without) much success to write some code at the > CMake config stage to test several different fast floor functions and use > whichever one works and is fastest. That would be a great thing. Thanks for the interesting link. By the way, the "Sree's Real2Int" solution is very likely to have some problems. It indeed looks very close to the solution used in some ITK filters which have problems with numbers that are very close to integer values. Indeed the following test fails: inline int BSplineFloor(double x) { #if defined mips  defined sparc  defined __ppc__ return (int)((unsigned int)(x + 2147483648.0)  2147483648U); #elif defined i386  defined _M_IX86 union { unsigned int hilo[2]; double d; } u; u.d = x + 103079215104.0; return (int)((u.hilo[1]<<16)(u.hilo[0]>>16)); #else return int(floor(x)); #endif } int main () { assert(BSplineFloor(0.999999)==0); } > However I would settle for something that works on a few platforms and > degrades gracefully on the rest. The main problem with ASM code is getting > that to work on 64 bit platforms. Well the ASM code works on 64 bit linux. I don't know about windows since I don't have such a machine avaliable. By the way, I am not convinced about the following comment in vn_math.h: // NB But Win64 does not support the nonstandard _asm It is maybe only necessary to use __asm (note the two underscores) instead of the deprecated _asm: http://msdn.microsoft.com/enus/library/45yd4tzz(VS.80).aspx > This is a really important speedup for randomaccess subsampling of images, > and if you can get it to work, I'd be happy to port it into vil (VXL's > imaging library) and convert the sampling code there to use it. The solution with the fistp and the divide by two trick works on all the machines we have (linux 32 and 64, mac intel and windows 32). > For image sampling code, any restriction to > [INT_MIN/2, INT_MAX/2] is not a problem. Same thing for us: [INT_MIN/2, INT_MAX/2] is not a problem. Regards, Tom 
From: Ian Scott <ian.scott@st...>  20080805 11:57:48

This problem has been on my todo list for over a year now, and a halfdecent fast floor operation would be really welcome. I've been using http://www.stereopsis.com/FPU.html and its references as a guide. I have been trying (without) much success to write some code at the CMake config stage to test several different fast floor functions and use whichever one works and is fastest. However I would settle for something that works on a few platforms and degrades gracefully on the rest. The main problem with ASM code is getting that to work on 64 bit platforms. This is a really important speedup for randomaccess subsampling of images, and if you can get it to work, I'd be happy to port it into vil (VXL's imaging library) and convert the sampling code there to use it. For image sampling code, any restriction to [INT_MIN/2, INT_MAX/2] is not a problem. Regards, Ian. Tom Vercauteren wrote: > Hi all, > > I hope this is the correct place to discuss this issue. > > In ITK, some filters need a fast function to cast a double into an int > with a mathematical floor operation. Right now a buggy code is used > for that. I'd like to fix it and make it cleaner. > > I think that a good solution would be to use some vxl functions for that. > > I now that there already is a fast round function called vnl_math_rnd > but it has some problems for halfway integers which have already been > discussed on this mailing list. See for example: > http://sourceforge.net/mailarchive/message.php?msg_id=47A1E3CF.9040407%40users.sourceforge.net > > Also vnl only provides round (no floor, no ceil). On the other hand, > vcl_floor is too slow for some heavy duty work. > > A solution that makes sense to me can be found here: > http://ldesoras.free.fr/doc/articles/rounding_en.pdf > > It provides fast round, floor and ceil with no issues at halway > integers. Of course it has know limitations: >  Only works within INT_MIN/2 – 1 and INT_MAX/2 + 1 >  Assumes that the FPU rounding mode has not been changed from the default one > > It basically uses the same assembly code than the one from > vnl_math_rnd but takes care of the halfway case by using a > multiplication by 2. > > Do you think it would be worth implementing such fast rounding > functions? If so, how should we proceed? > > Best regards, > Tom Vercauteren > >  > This SF.Net email is sponsored by the Moblin Your Move Developer's challenge > Build the coolest Linux based applications with Moblin SDK & win great prizes > Grand prize is a trip for two to an Open Source event anywhere in the world > http://moblincontest.org/redirect.php?banner_id=100&url=/ > _______________________________________________ > Vxlmaintainers mailing list > Vxlmaintainers@... > https://lists.sourceforge.net/lists/listinfo/vxlmaintainers 
From: Tom Vercauteren <tom.vercauteren@gm...>  20080805 11:37:33

> The best thing to do I believe is to insert at least the following 8 lines at line 181 of core/vnl/vnl_math.h : > > =============================================== > // floor  round towards minus infinity > inline int vnl_math_floor(float x) { return (x>=0.0)?(int)(x):(int)(x); } > inline int vnl_math_floor(double x) { return (x>=0.0)?(int)(x):(int)(x); } > > // ceil  round towards plus infinity > inline int vnl_math_ceil(float x) { return (x>=0.0)?(int)(x):(int)(x); } > inline int vnl_math_ceil(double x) { return (x>=0.0)?(int)(x):(int)(x); } > =============================================== > > and supplement these with the appropriate __asm which as you pointed out is very similar to the code for vnl_math_rnd. Seems fine to me! > Also the "divide by 2" trick in that article is interesting  we should add it to the implementation of vnl_math_rnd: 8.50 should round to 9, not to 8, I would say. I agree that the "divide by 2" trick is great. Actually, we use such a code on both gcc and msvc by default instead of the lround calls. It proved to be faster. It might however also be interesting to allow the user to use the full int range instead of restricting it to INT_MIN/2 to INT_MAX/2. On MSVC, the round functions we use are: inline int vnl_math_rnd(double x) { int r; x = 2*x+.5; __asm { fld x fistp r } return r>>1; } inline int vnl_math_rnd(float x) { int r; x = 2*x+.5f; __asm { fld x fistp r } return r>>1; } Similarly on gcc: inline int vnl_math_rnd(double x) { // assert(fegetround()==FE_TONEAREST); // assert (x > static_cast <double> (INT_MIN / 2) – 1.0); // assert (x < static_cast <double> (INT_MAX / 2) + 1.0); int r; x = 2*x+.5; __asm__ __volatile__ ("fistpl %0" : "=m"(r) : "t"(x) : "st"); return r>>1; } inline int vnl_math_rnd(float x) { int r; x = 2*x+.5f; __asm__ __volatile__ ("fistpl %0" : "=m"(r) : "t"(x) : "st"); return r>>1; } 
From: Peter Vanroose <peter_vanroose@ya...>  20080805 10:34:46

Tom Vercauteren wrote: > http://ldesoras.free.fr/doc/articles/rounding_en.pdf Interesting article! The best thing to do I believe is to insert at least the following 8 lines at line 181 of core/vnl/vnl_math.h : =============================================== // floor  round towards minus infinity inline int vnl_math_floor(float x) { return (x>=0.0)?(int)(x):(int)(x); } inline int vnl_math_floor(double x) { return (x>=0.0)?(int)(x):(int)(x); } // ceil  round towards plus infinity inline int vnl_math_ceil(float x) { return (x>=0.0)?(int)(x):(int)(x); } inline int vnl_math_ceil(double x) { return (x>=0.0)?(int)(x):(int)(x); } =============================================== and supplement these with the appropriate __asm which as you pointed out is very similar to the code for vnl_math_rnd. Also the "divide by 2" trick in that article is interesting  we should add it to the implementation of vnl_math_rnd: 8.50 should round to 9, not to 8, I would say.  Peter. __________________________________________________________ Låna pengar utan säkerhet. Jämför vilkor online hos Kelkoo. http://www.kelkoo.se/c100390123lanutansakerhet.html?partnerId=96915014 
From: Tom Vercauteren <tom.vercauteren@gm...>  20080805 08:38:13

Hi all, I hope this is the correct place to discuss this issue. In ITK, some filters need a fast function to cast a double into an int with a mathematical floor operation. Right now a buggy code is used for that. I'd like to fix it and make it cleaner. I think that a good solution would be to use some vxl functions for that. I now that there already is a fast round function called vnl_math_rnd but it has some problems for halfway integers which have already been discussed on this mailing list. See for example: http://sourceforge.net/mailarchive/message.php?msg_id=47A1E3CF.9040407%40users.sourceforge.net Also vnl only provides round (no floor, no ceil). On the other hand, vcl_floor is too slow for some heavy duty work. A solution that makes sense to me can be found here: http://ldesoras.free.fr/doc/articles/rounding_en.pdf It provides fast round, floor and ceil with no issues at halway integers. Of course it has know limitations:  Only works within INT_MIN/2 – 1 and INT_MAX/2 + 1  Assumes that the FPU rounding mode has not been changed from the default one It basically uses the same assembly code than the one from vnl_math_rnd but takes care of the halfway case by using a multiplication by 2. Do you think it would be worth implementing such fast rounding functions? If so, how should we proceed? Best regards, Tom Vercauteren 