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

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}
(390) 
_{Aug}
(767) 
_{Sep}
(940) 
_{Oct}
(964) 
_{Nov}
(819) 
_{Dec}
(762) 

2001 
_{Jan}
(680) 
_{Feb}
(1075) 
_{Mar}
(954) 
_{Apr}
(595) 
_{May}
(725) 
_{Jun}
(868) 
_{Jul}
(678) 
_{Aug}
(785) 
_{Sep}
(410) 
_{Oct}
(395) 
_{Nov}
(374) 
_{Dec}
(419) 
2002 
_{Jan}
(699) 
_{Feb}
(501) 
_{Mar}
(311) 
_{Apr}
(334) 
_{May}
(501) 
_{Jun}
(507) 
_{Jul}
(441) 
_{Aug}
(395) 
_{Sep}
(540) 
_{Oct}
(416) 
_{Nov}
(369) 
_{Dec}
(373) 
2003 
_{Jan}
(514) 
_{Feb}
(488) 
_{Mar}
(396) 
_{Apr}
(624) 
_{May}
(590) 
_{Jun}
(562) 
_{Jul}
(546) 
_{Aug}
(463) 
_{Sep}
(389) 
_{Oct}
(399) 
_{Nov}
(333) 
_{Dec}
(449) 
2004 
_{Jan}
(317) 
_{Feb}
(395) 
_{Mar}
(136) 
_{Apr}
(338) 
_{May}
(488) 
_{Jun}
(306) 
_{Jul}
(266) 
_{Aug}
(424) 
_{Sep}
(502) 
_{Oct}
(170) 
_{Nov}
(170) 
_{Dec}
(134) 
2005 
_{Jan}
(249) 
_{Feb}
(109) 
_{Mar}
(119) 
_{Apr}
(282) 
_{May}
(82) 
_{Jun}
(113) 
_{Jul}
(56) 
_{Aug}
(160) 
_{Sep}
(89) 
_{Oct}
(98) 
_{Nov}
(237) 
_{Dec}
(297) 
2006 
_{Jan}
(151) 
_{Feb}
(250) 
_{Mar}
(222) 
_{Apr}
(147) 
_{May}
(266) 
_{Jun}
(313) 
_{Jul}
(367) 
_{Aug}
(135) 
_{Sep}
(108) 
_{Oct}
(110) 
_{Nov}
(220) 
_{Dec}
(47) 
2007 
_{Jan}
(133) 
_{Feb}
(144) 
_{Mar}
(247) 
_{Apr}
(191) 
_{May}
(191) 
_{Jun}
(171) 
_{Jul}
(160) 
_{Aug}
(51) 
_{Sep}
(125) 
_{Oct}
(115) 
_{Nov}
(78) 
_{Dec}
(67) 
2008 
_{Jan}
(165) 
_{Feb}
(37) 
_{Mar}
(130) 
_{Apr}
(111) 
_{May}
(91) 
_{Jun}
(142) 
_{Jul}
(54) 
_{Aug}
(104) 
_{Sep}
(89) 
_{Oct}
(87) 
_{Nov}
(44) 
_{Dec}
(54) 
2009 
_{Jan}
(283) 
_{Feb}
(113) 
_{Mar}
(154) 
_{Apr}
(395) 
_{May}
(62) 
_{Jun}
(48) 
_{Jul}
(52) 
_{Aug}
(54) 
_{Sep}
(131) 
_{Oct}
(29) 
_{Nov}
(32) 
_{Dec}
(37) 
2010 
_{Jan}
(34) 
_{Feb}
(36) 
_{Mar}
(40) 
_{Apr}
(23) 
_{May}
(38) 
_{Jun}
(34) 
_{Jul}
(36) 
_{Aug}
(27) 
_{Sep}
(9) 
_{Oct}
(18) 
_{Nov}
(25) 
_{Dec}

2011 
_{Jan}
(1) 
_{Feb}
(14) 
_{Mar}
(1) 
_{Apr}
(5) 
_{May}
(1) 
_{Jun}

_{Jul}

_{Aug}
(37) 
_{Sep}
(6) 
_{Oct}
(2) 
_{Nov}

_{Dec}

2012 
_{Jan}

_{Feb}
(7) 
_{Mar}

_{Apr}
(4) 
_{May}

_{Jun}
(3) 
_{Jul}

_{Aug}

_{Sep}
(1) 
_{Oct}

_{Nov}

_{Dec}
(10) 
2013 
_{Jan}

_{Feb}
(1) 
_{Mar}
(7) 
_{Apr}
(2) 
_{May}

_{Jun}

_{Jul}
(9) 
_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

2014 
_{Jan}
(14) 
_{Feb}

_{Mar}
(2) 
_{Apr}

_{May}
(10) 
_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}
(3) 
_{Dec}

2015 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}
(12) 
_{Nov}

_{Dec}
(1) 
S  M  T  W  T  F  S 

1

2

3

4
(11) 
5
(1) 
6
(2) 
7
(1) 
8
(7) 
9

10
(2) 
11
(7) 
12
(1) 
13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30






From: Nathaniel Hoffman <naty@io...>  20091104 15:37:21

> What are you using this for? If it's lighting or shading, there's no > real reason to use a power function on the cosine term to get tighter > specular highlights. It's just a shaping function that people use > because it's easy to control and AFAICT it has no physical basis in > defining a BRDF from the micropolygon point of view. > >  Robin Green. It's true that there is no reason to _exactly_ match a cosine power, and I agree with Robin that for this purpose, any curve which vaguely resembles cosine power will do. As a side note, I just wanted to say a few words in the defense of the lowly cosine power  it's not completely physically meaningless. If you are using BlinnPhong (N dot H, which is much to be preferred over original Phong  R dot L), then using a cosine power is equivalent to assuming that the microfacet normal distribution follows a cosine power curve. Now, there is no physical reason to assume that microfacet distributions necessarily follow a cosine power curve, but (except for very low powers) this curve very closely matches one that _does_ have a physical basis  the Beckmann distribution (the one used in the CookTorrance BRDF). The match is amazingly close considering that BuiTong Phong just eyeballed the function; he didn't do any curve fitting. BTW, Beckmann's behavior for very low powers is interesting  it stops behaving like a Gaussianish blob and starts turning insideout (which makes sense when you look at the definition of the "m" parameter). Beckmann isn't the last word on microfacet distributions; the EGSR 2007 paper "Microfacet Models for Refraction through Rough Surfaces" (which is a great paper overall and well worth reading for anyone interested in microfacet BRDFs) makes a good case for a different curve, with a more gradual falloff. Which again supports Robin's original point. Naty Hoffman 
From: Robin Green <robin.green@gm...>  20091104 14:47:44

Lack of coffee made be forget this  if you don't give a monkey's about numerical accuracy and only want powerlike curves, go right ahead and use a fast exp() and log() to build your own power function. Details of quick'n'dirty medium accuracy implementations are available here: http://www.research.scea.com/gdc2003/fastmathfunctions.html or in Game Programming Gems.  Robin Green. On Wed, Nov 4, 2009 at 6:32 AM, Robin Green <robin.green@...> wrote: > Your real problem is that the range of x is unconstrained. Looking at > how pow() is calculated: > > pow(n,x) = exp(log(x)*n) > > You've simplified the exponent to exp(y+0) .. exp(y+1), but as y is > unconstrained you've really gained nothing. The main problem with > implementing pow() is that naive code can lose many digits of > significance during the calculation if you don't calculate the log and > multiply using extended precision, e.g. if you want a 24bit result > you'll need to calculate the intermediate values to 30 or more bits of > accuracy. This is done by splitting the problem into a high part and a > low part and combining the two at the reconstruction phase. For > example, here's an implementation of powf(): > > http://www.koders.com/c/fidF4B379CC08D80BEE9CD9B65E01302343E03BF4A7.aspx?s=Chebyshev > > The exp() is a great function to minimax as it only requires a few > terms to approach 24bit accuracy, but log() is a painfully different > story often requiring table lookups (memory hits) to function well > across the full number range. > > What are you using this for? If it's lighting or shading, there's no > real reason to use a power function on the cosine term to get tighter > specular highlights. It's just a shaping function that people use > because it's easy to control and AFAICT it has no physical basis in > defining a BRDF from the micropolygon point of view. > >  Robin Green. > > On Tue, Nov 3, 2009 at 7:45 PM, Juan Linietsky <reduzio@...> wrote: >> Hi guys! I was wondering if there are fast ways to approximate the >> curve resulting from pow(n,x) where n is in range [0..1] and x > 0 >> using only floating point (without strange pointer casts/etc).. >> >> Cheers >> >> Juan Linietsky > 
From: Robin Green <robin.green@gm...>  20091104 14:32:38

Your real problem is that the range of x is unconstrained. Looking at how pow() is calculated: pow(n,x) = exp(log(x)*n) You've simplified the exponent to exp(y+0) .. exp(y+1), but as y is unconstrained you've really gained nothing. The main problem with implementing pow() is that naive code can lose many digits of significance during the calculation if you don't calculate the log and multiply using extended precision, e.g. if you want a 24bit result you'll need to calculate the intermediate values to 30 or more bits of accuracy. This is done by splitting the problem into a high part and a low part and combining the two at the reconstruction phase. For example, here's an implementation of powf(): http://www.koders.com/c/fidF4B379CC08D80BEE9CD9B65E01302343E03BF4A7.aspx?s=Chebyshev The exp() is a great function to minimax as it only requires a few terms to approach 24bit accuracy, but log() is a painfully different story often requiring table lookups (memory hits) to function well across the full number range. What are you using this for? If it's lighting or shading, there's no real reason to use a power function on the cosine term to get tighter specular highlights. It's just a shaping function that people use because it's easy to control and AFAICT it has no physical basis in defining a BRDF from the micropolygon point of view.  Robin Green. On Tue, Nov 3, 2009 at 7:45 PM, Juan Linietsky <reduzio@...> wrote: > Hi guys! I was wondering if there are fast ways to approximate the > curve resulting from pow(n,x) where n is in range [0..1] and x > 0 > using only floating point (without strange pointer casts/etc).. > > Cheers > > Juan Linietsky 
From: Danny Kodicek <dragon@we...>  20091104 12:50:43

> x^m = exp(m log x) > > > So really you need a fast exp and log function. > > > Can you newtonraphson refine a log and exp calculation? > I've never tried ... perhaps someone else can help there. > > > Failing that you could probably use tables for the > calculations though this, obviously, limits the range of > powers you can perform. I know nothing about this but one thing that pops into my head is that exp and log both have a lot of selfsimilarity features so I wonder whether that would help. I once experimented with using a lookup table with very few entries and catmullrom interpolation between them. It was just playing, but I do remember getting surprisingly fast results on sin and cos. Danny (aware he's out of his depth...) 
From: Richard Fabian <raspo1@gm...>  20091104 11:59:26

I'm generally having a problem with the definition of the problem. Curve for me defines that this is a differentiation, but i feel that it's probably not. Not using clever bit ops seems pointless if you're after a lot of speed, and a lookup table might be more expensive because of the memory access. I think we need the problem defined better. Give us some context! 2009/11/4 Oscar Forth <oscar@...> > x^m = exp(m log x) > > So really you need a fast exp and log function. > > Can you newtonraphson refine a log and exp calculation? I've never tried > ... perhaps someone else can help there. > > Failing that you could probably use tables for the calculations though > this, obviously, limits the range of powers you can perform. > > 2009/11/4 Juan Linietsky <reduzio@...> > > Hi guys! I was wondering if there are fast ways to approximate the >> curve resulting from pow(n,x) where n is in range [0..1] and x > 0 >> using only floating point (without strange pointer casts/etc).. >> >> Cheers >> >> Juan Linietsky >> >> >>  >> Let Crystal Reports handle the reporting  Free Crystal Reports 2008 >> 30Day >> trial. Simplify your report design, integration and deployment  and focus >> on >> what you do best, core application coding. Discover what's new with >> Crystal Reports now. http://p.sf.net/sfu/bobjjuly >> _______________________________________________ >> GDAlgorithmslist mailing list >> GDAlgorithmslist@... >> https://lists.sourceforge.net/lists/listinfo/gdalgorithmslist >> Archives: >> http://sourceforge.net/mailarchive/forum.php?forum_name=gdalgorithmslist >> > > > >  > Let Crystal Reports handle the reporting  Free Crystal Reports 2008 30Day > trial. Simplify your report design, integration and deployment  and focus > on > what you do best, core application coding. Discover what's new with > Crystal Reports now. http://p.sf.net/sfu/bobjjuly > _______________________________________________ > GDAlgorithmslist mailing list > GDAlgorithmslist@... > https://lists.sourceforge.net/lists/listinfo/gdalgorithmslist > Archives: > http://sourceforge.net/mailarchive/forum.php?forum_name=gdalgorithmslist >  fabs(); Just because the world is full of people that think just like you, doesn't mean the other ones can't be right. 
From: Oscar Forth <oscar@tr...>  20091104 11:32:29

x^m = exp(m log x) So really you need a fast exp and log function. Can you newtonraphson refine a log and exp calculation? I've never tried ... perhaps someone else can help there. Failing that you could probably use tables for the calculations though this, obviously, limits the range of powers you can perform. 2009/11/4 Juan Linietsky <reduzio@...> > Hi guys! I was wondering if there are fast ways to approximate the > curve resulting from pow(n,x) where n is in range [0..1] and x > 0 > using only floating point (without strange pointer casts/etc).. > > Cheers > > Juan Linietsky > > >  > Let Crystal Reports handle the reporting  Free Crystal Reports 2008 30Day > trial. Simplify your report design, integration and deployment  and focus > on > what you do best, core application coding. Discover what's new with > Crystal Reports now. http://p.sf.net/sfu/bobjjuly > _______________________________________________ > GDAlgorithmslist mailing list > GDAlgorithmslist@... > https://lists.sourceforge.net/lists/listinfo/gdalgorithmslist > Archives: > http://sourceforge.net/mailarchive/forum.php?forum_name=gdalgorithmslist > 
From: Juan Linietsky <reduzio@gm...>  20091104 03:45:43

Hi guys! I was wondering if there are fast ways to approximate the curve resulting from pow(n,x) where n is in range [0..1] and x > 0 using only floating point (without strange pointer casts/etc).. Cheers Juan Linietsky 