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

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}
(4) 
_{Jul}
(1) 
_{Aug}

_{Sep}
(15) 
_{Oct}
(32) 
_{Nov}
(35) 
_{Dec}
(48) 

2001 
_{Jan}
(46) 
_{Feb}
(22) 
_{Mar}
(65) 
_{Apr}
(49) 
_{May}
(22) 
_{Jun}
(29) 
_{Jul}
(51) 
_{Aug}
(34) 
_{Sep}
(32) 
_{Oct}
(46) 
_{Nov}
(30) 
_{Dec}
(32) 
2002 
_{Jan}
(48) 
_{Feb}
(4) 
_{Mar}
(20) 
_{Apr}
(28) 
_{May}
(13) 
_{Jun}
(34) 
_{Jul}
(51) 
_{Aug}
(15) 
_{Sep}
(15) 
_{Oct}
(35) 
_{Nov}
(15) 
_{Dec}
(20) 
2003 
_{Jan}
(31) 
_{Feb}
(111) 
_{Mar}
(41) 
_{Apr}
(28) 
_{May}
(36) 
_{Jun}
(29) 
_{Jul}
(27) 
_{Aug}
(29) 
_{Sep}
(47) 
_{Oct}
(28) 
_{Nov}
(7) 
_{Dec}
(26) 
2004 
_{Jan}
(44) 
_{Feb}
(9) 
_{Mar}
(17) 
_{Apr}
(26) 
_{May}
(58) 
_{Jun}
(13) 
_{Jul}
(44) 
_{Aug}
(64) 
_{Sep}
(30) 
_{Oct}
(11) 
_{Nov}
(21) 
_{Dec}
(28) 
2005 
_{Jan}
(29) 
_{Feb}
(11) 
_{Mar}
(11) 
_{Apr}
(22) 
_{May}
(85) 
_{Jun}
(46) 
_{Jul}
(17) 
_{Aug}
(18) 
_{Sep}
(14) 
_{Oct}
(22) 
_{Nov}
(1) 
_{Dec}
(45) 
2006 
_{Jan}
(20) 
_{Feb}
(36) 
_{Mar}
(18) 
_{Apr}
(24) 
_{May}
(21) 
_{Jun}
(48) 
_{Jul}
(23) 
_{Aug}
(20) 
_{Sep}
(10) 
_{Oct}
(41) 
_{Nov}
(46) 
_{Dec}
(40) 
2007 
_{Jan}
(40) 
_{Feb}
(20) 
_{Mar}
(13) 
_{Apr}
(6) 
_{May}
(24) 
_{Jun}
(31) 
_{Jul}
(30) 
_{Aug}
(11) 
_{Sep}
(11) 
_{Oct}
(10) 
_{Nov}
(56) 
_{Dec}
(64) 
2008 
_{Jan}
(64) 
_{Feb}
(22) 
_{Mar}
(63) 
_{Apr}
(28) 
_{May}
(25) 
_{Jun}
(36) 
_{Jul}
(11) 
_{Aug}
(9) 
_{Sep}
(14) 
_{Oct}
(41) 
_{Nov}
(46) 
_{Dec}
(130) 
2009 
_{Jan}
(95) 
_{Feb}
(41) 
_{Mar}
(24) 
_{Apr}
(35) 
_{May}
(53) 
_{Jun}
(67) 
_{Jul}
(48) 
_{Aug}
(48) 
_{Sep}
(86) 
_{Oct}
(75) 
_{Nov}
(64) 
_{Dec}
(52) 
2010 
_{Jan}
(57) 
_{Feb}
(31) 
_{Mar}
(28) 
_{Apr}
(40) 
_{May}
(25) 
_{Jun}
(42) 
_{Jul}
(79) 
_{Aug}
(31) 
_{Sep}
(49) 
_{Oct}
(66) 
_{Nov}
(38) 
_{Dec}
(25) 
2011 
_{Jan}
(29) 
_{Feb}
(18) 
_{Mar}
(44) 
_{Apr}
(6) 
_{May}
(28) 
_{Jun}
(31) 
_{Jul}
(36) 
_{Aug}
(24) 
_{Sep}
(30) 
_{Oct}
(23) 
_{Nov}
(21) 
_{Dec}
(27) 
2012 
_{Jan}
(14) 
_{Feb}
(11) 
_{Mar}
(2) 
_{Apr}
(48) 
_{May}
(7) 
_{Jun}
(32) 
_{Jul}
(22) 
_{Aug}
(25) 
_{Sep}
(31) 
_{Oct}
(32) 
_{Nov}
(21) 
_{Dec}
(17) 
2013 
_{Jan}
(44) 
_{Feb}
(27) 
_{Mar}
(3) 
_{Apr}
(1) 
_{May}

_{Jun}

_{Jul}
(3) 
_{Aug}
(4) 
_{Sep}
(1) 
_{Oct}
(7) 
_{Nov}
(5) 
_{Dec}
(5) 
2014 
_{Jan}

_{Feb}

_{Mar}

_{Apr}
(3) 
_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

S  M  T  W  T  F  S 







1

2

3

4

5

6
(1) 
7

8

9

10

11
(1) 
12
(2) 
13

14

15

16

17

18

19

20

21
(2) 
22
(5) 
23
(4) 
24

25
(11) 
26
(8) 
27
(9) 
28
(2) 
29
(8) 
30
(7) 
31
(4) 





From: Bruce Sherwood <Bruce_S<herwood@nc...>  20071231 19:21:16

I repeated my own timings and then remembered why I didn't use try/except. The try/except scheme does give the fastest square root of a scalar (1.2 microsec on my 1 GHz laptop) but doubles the time for sqrt(array([1,2,3,4,5,6,7,8,9,10])), from about 10 microsec to about 20 microsec. So I've settled for the following, which gives sqrt(scalar) of 1.7 microsec and almost no change in sqrt(array): def sqrt(x): t = type(x) if t is float or t is int or t is long: return _m_sqrt(x) return _n_sqrt(x) Thanks again for thinking about this issue, and for alerting me to check not just for float. Bruce Sherwood P.S. What's in the justreleased 4.beta22 only checks for float, but the correction is now in CVS. Scott David Daniels wrote: > Bruce Sherwood wrote: > >> In a test version not yet released I've implemented essentially the >> scheme suggested by Scott David Daniels, and it works very well. Thanks! >> >> I found by timing measurements that a faster scheme with less penalty >> for the case of sqrt(array) looks like this: >> >> def sqrt(x): >> if type(x) is float: return mathsqrt(x) >> return numpysqrt(x) >> >> This scheme not only solves the problem but actually yields faster >> square roots of scalar arguments than numpy, by about a factor of 3. So >> what was conceived as a workaround is actually a performance enhancement. >> > > I actually did a bit of timing before I suggested the try/except version. > I use subclasses of ints and floats in some of the code I write. > A simple example (to make values more obvious): > class Float(float): > def __repr__(self): > return '%s(%s)' % (self.__class__.__name__, > float.__repr__(self)) > class Meters(Float): pass > class Grams(Float): pass > ... > Then I can make physical constants a little more obvious interactively. > > My first version was: > def sqrt(x): > if isinstance(x, (int, long, float)): > return mathsqrt(x) > else: > return numpysqrt(x) > > I then realized math.sqrt was already doing this check. Since the check > is already there, I decided not to slow down the more common scalar > case. That was when I switched to the "try: ... except TypeError: ..." > form (to use math.sqrt's type checks). I then made sure performance on > a short (tenelement) vector was not too severely impacted. If you > still want to exact match on types, I'd suggest accepting at least > floats and ints, since you'll otherwise get performance reports about > how much slower sqrt(4) is than sqrt(4.0). > > Something more like: > def sqrt(x): > t = type(x) > if t is float or t is int: > return mathsqrt(x) > else: > return numpysqrt(x) > > Scott David Daniels > Scott.Daniels@... > > >  > This SF.net email is sponsored by: Microsoft > Defy all challenges. Microsoft(R) Visual Studio 2005. > http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/ > _______________________________________________ > Visualpythonusers mailing list > Visualpythonusers@... > https://lists.sourceforge.net/lists/listinfo/visualpythonusers > 
From: Bruce Sherwood <Bruce_S<herwood@nc...>  20071231 18:46:34

4.beta22 now available for Windows and Linux at sourceforge. Fixed a bug which made rendering of spheres very slow. When doing some experiments on adjusting the level of detail for spheres, Arthur Siegel in December 2006 commented out the statement that used a cached description of a sphere. The effect was to recompute a 3D model of every sphere in every render cycle. There are still some issues with slow rendering in the beta version, but this was certainly the most serious bug. The recently contributed program vspace.py now runs on the beta version, though not as well as on the production version of VPython. Bruce Sherwood 
From: Bruce Sherwood <Bruce_S<herwood@nc...>  20071231 05:25:42

Good points. Thanks. Bruce Sherwood Scott David Daniels wrote: > Bruce Sherwood wrote: > >> In a test version not yet released I've implemented essentially the >> scheme suggested by Scott David Daniels, and it works very well. Thanks! >> >> I found by timing measurements that a faster scheme with less penalty >> for the case of sqrt(array) looks like this: >> >> def sqrt(x): >> if type(x) is float: return mathsqrt(x) >> return numpysqrt(x) >> >> This scheme not only solves the problem but actually yields faster >> square roots of scalar arguments than numpy, by about a factor of 3. So >> what was conceived as a workaround is actually a performance enhancement. >> > > I actually did a bit of timing before I suggested the try/except version. > I use subclasses of ints and floats in some of the code I write. > A simple example (to make values more obvious): > class Float(float): > def __repr__(self): > return '%s(%s)' % (self.__class__.__name__, > float.__repr__(self)) > class Meters(Float): pass > class Grams(Float): pass > ... > Then I can make physical constants a little more obvious interactively. > > My first version was: > def sqrt(x): > if isinstance(x, (int, long, float)): > return mathsqrt(x) > else: > return numpysqrt(x) > > I then realized math.sqrt was already doing this check. Since the check > is already there, I decided not to slow down the more common scalar > case. That was when I switched to the "try: ... except TypeError: ..." > form (to use math.sqrt's type checks). I then made sure performance on > a short (tenelement) vector was not too severely impacted. If you > still want to exact match on types, I'd suggest accepting at least > floats and ints, since you'll otherwise get performance reports about > how much slower sqrt(4) is than sqrt(4.0). > > Something more like: > def sqrt(x): > t = type(x) > if t is float or t is int: > return mathsqrt(x) > else: > return numpysqrt(x) > > Scott David Daniels > Scott.Daniels@... > > >  > This SF.net email is sponsored by: Microsoft > Defy all challenges. Microsoft(R) Visual Studio 2005. > http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/ > _______________________________________________ > Visualpythonusers mailing list > Visualpythonusers@... > https://lists.sourceforge.net/lists/listinfo/visualpythonusers > 
From: Ron Adam <rrr@ro...>  20071231 04:01:27

Bruce Sherwood wrote: > That's a spectacular demonstration of work that needs to be done on the > beta version, as it takes 5 seconds (!) to render the scene on my > laptop, whereas the display and motion are completely smooth in the > production version of VPython. I could possibly change it to add the asteroid objects after the main loop is started until a desired frame rate is achieved. It will still run smoothly on slower computers that way. And display the object count in a corner for comparisons. > I've added this to the contributed section of vpython.org. Thanks! You're welcome, it was fun to figure out how to do it too. Ron > I deleted the unnecessary line that made the mouse cursor visible, since > that's the default and this feature is as yet missing from the beta > version, should someone wish to see the extreme slowness of the rendering. > > Bruce Sherwood > Ron Adam wrote: >> >> Bruce Sherwood wrote: >>> Questions were asked recently about looking outward from the origin >>> (or other location) and rotating the view of the surrounding scene. >>> As an example of this kind of viewing, see look_around.py in the >>> contributed section of vpython.org. >>> >>> Bruce Sherwood >> Here's a fun demo that uses rotating and spin I meant to submit some >> time ago and never did. >> >> Enjoy, >> Ron Adam >>  >> >>  >> This SF.net email is sponsored by: Microsoft >> Defy all challenges. Microsoft(R) Visual Studio 2005. >> http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/ >>  >> >> _______________________________________________ >> Visualpythonusers mailing list >> Visualpythonusers@... >> https://lists.sourceforge.net/lists/listinfo/visualpythonusers > >  > This SF.net email is sponsored by: Microsoft > Defy all challenges. Microsoft(R) Visual Studio 2005. > http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/ 
From:
<frederic.mantegazza@gb...>  20071230 23:25:58

On dimanche 30 d=E9cembre 2007, Bruce Sherwood wrote: > Okay, I've commented the tricky geometry calculations. Thank you very much :o) I'll try to apply this to my panohead.. =2D=20 Fr=E9d=E9ric http://www.gbiloba.org 
From: Scott David Daniels <Scott.Daniels@Acm.Org>  20071230 21:52:51

Bruce Sherwood wrote: > In a test version not yet released I've implemented essentially the > scheme suggested by Scott David Daniels, and it works very well. Thanks! > > I found by timing measurements that a faster scheme with less penalty > for the case of sqrt(array) looks like this: > > def sqrt(x): > if type(x) is float: return mathsqrt(x) > return numpysqrt(x) > > This scheme not only solves the problem but actually yields faster > square roots of scalar arguments than numpy, by about a factor of 3. So > what was conceived as a workaround is actually a performance enhancement. I actually did a bit of timing before I suggested the try/except version. I use subclasses of ints and floats in some of the code I write. A simple example (to make values more obvious): class Float(float): def __repr__(self): return '%s(%s)' % (self.__class__.__name__, float.__repr__(self)) class Meters(Float): pass class Grams(Float): pass ... Then I can make physical constants a little more obvious interactively. My first version was: def sqrt(x): if isinstance(x, (int, long, float)): return mathsqrt(x) else: return numpysqrt(x) I then realized math.sqrt was already doing this check. Since the check is already there, I decided not to slow down the more common scalar case. That was when I switched to the "try: ... except TypeError: ..." form (to use math.sqrt's type checks). I then made sure performance on a short (tenelement) vector was not too severely impacted. If you still want to exact match on types, I'd suggest accepting at least floats and ints, since you'll otherwise get performance reports about how much slower sqrt(4) is than sqrt(4.0). Something more like: def sqrt(x): t = type(x) if t is float or t is int: return mathsqrt(x) else: return numpysqrt(x) Scott David Daniels Scott.Daniels@... 
From: Bruce Sherwood <Bruce_S<herwood@nc...>  20071230 18:44:33

Okay, I've commented the tricky geometry calculations. Bruce Sherwood Frédéric Mantegazza wrote: > On samedi 29 décembre 2007, Bruce Sherwood wrote: > >> Questions were asked recently about looking outward from the origin (or >> other location) and rotating the view of the surrounding scene. As an >> example of this kind of viewing, see look_around.py in the contributed >> section of vpython.org. >> > > I'm not sure to clearly understand how it works. Could you detail your > code, please? > > 
From: Rob Salgado <salgado@ph...>  20071230 13:43:08

I too recently stumbled upon Johnny Chung Lee's Wii projects. As an alternative when the main page http://www.cs.cmu.edu/~johnny/projects/wii/ fails, You can always try the Google cache, by first doing the search: http://www.google.com/search?q=%22Johnny+Chung+Lee%22 then following the appropriate "Cache" link. For the YouTube videos he posted, consult http://www.youtube.com/profile?user=jcl5m Last week, I played around with GlovePIE http://carl.kenner.googlepages.com/glovepie to see how the Wii Remote interacts with my laptop via Bluetooth. When my I buy my own Wii Remote [since I was trying one from my brother's Wii] and some IRLEDs, I'm going to play around with some of Johnny Chung Lee's ideas. rob 
From: P H Borcherds <p.borcherds@bh...>  20071230 13:05:19

Dear Vpython Group I have had some (intermittent) success with the link Bruce supplied http://www.cs.cmu.edu/~johnny/projects/wii/ I entered the above into Google, and clicked "I'm feeling lucky" The first time , this got me through to Johnny Chung Lee's page, but next time, it did not! I am attaching a copy of the page: hope it reaches you Regards Peter P H Borcherds phone +44 121 475 3029 p.h.borcherds@... 
From:
<frederic.mantegazza@gb...>  20071230 10:37:06

On samedi 29 d=E9cembre 2007, Bruce Sherwood wrote: > Questions were asked recently about looking outward from the origin (or > other location) and rotating the view of the surrounding scene. As an > example of this kind of viewing, see look_around.py in the contributed > section of vpython.org. I'm not sure to clearly understand how it works. Could you detail your=20 code, please? =2D=20 Fr=E9d=E9ric http://www.gbiloba.org 
From:
<frederic.mantegazza@gb...>  20071230 09:55:43

On dimanche 30 d=E9cembre 2007, Bruce Sherwood wrote: > That's a spectacular demonstration of work that needs to be done on the > beta version, as it takes 5 seconds (!) to render the scene on my > laptop, whereas the display and motion are completely smooth in the > production version of VPython. > > I've added this to the contributed section of vpython.org. Thanks! > > I deleted the unnecessary line that made the mouse cursor visible, since > that's the default and this feature is as yet missing from the beta > version, should someone wish to see the extreme slowness of the > rendering. I saw ;o) =2D=20 Fr=E9d=E9ric http://www.gbiloba.org 
From: Bruce Sherwood <Bruce_S<herwood@nc...>  20071229 23:39:36

That's a spectacular demonstration of work that needs to be done on the beta version, as it takes 5 seconds (!) to render the scene on my laptop, whereas the display and motion are completely smooth in the production version of VPython. I've added this to the contributed section of vpython.org. Thanks! I deleted the unnecessary line that made the mouse cursor visible, since that's the default and this feature is as yet missing from the beta version, should someone wish to see the extreme slowness of the rendering. Bruce Sherwood Ron Adam wrote: > > > Bruce Sherwood wrote: >> Questions were asked recently about looking outward from the origin >> (or other location) and rotating the view of the surrounding scene. >> As an example of this kind of viewing, see look_around.py in the >> contributed section of vpython.org. >> >> Bruce Sherwood > > Here's a fun demo that uses rotating and spin I meant to submit some > time ago and never did. > > Enjoy, > Ron Adam >  > >  > This SF.net email is sponsored by: Microsoft > Defy all challenges. Microsoft(R) Visual Studio 2005. > http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/ >  > > _______________________________________________ > Visualpythonusers mailing list > Visualpythonusers@... > https://lists.sourceforge.net/lists/listinfo/visualpythonusers 
From: Bruce Sherwood <Bruce_S<herwood@nc...>  20071229 23:05:23

In a test version not yet released I've implemented essentially the scheme suggested by Scott David Daniels, and it works very well. Thanks! I found by timing measurements that a faster scheme with less penalty for the case of sqrt(array) looks like this: def sqrt(x): if type(x) is float: return mathsqrt(x) return numpysqrt(x) This scheme not only solves the problem but actually yields faster square roots of scalar arguments than numpy, by about a factor of 3. So what was conceived as a workaround is actually a performance enhancement. Bruce Sherwood Scott David Daniels wrote: > I (Scott David Daniels) wrote: > >> I'm not sure of the overhead here, but could something like this work? >> >> def sqrt(x): >> try: return math.sqrt(x) >> except TypeError: return numpy.sqrt(x) >> > > If it "kinda" works, the following addition to __init__ should work: > > from numpy import (ceil as _n_ceil, cos as _n_cos, cosh as _n_cosh, > exp as _n_exp, fabs as _n_fabs, floor as _n_floor, > fmod as _n_fmod, frexp as _n_frexp, hypot as _n_hypot, > ldexp as _n_ldexp, log as _n_log, log10 as _n_log10, > modf as _n_modf, sin as _n_sin, sinh as _n_sinh, > sqrt as _n_sqrt, tan as _n_tan, tanh as _n_tanh) > from math import (ceil as _m_ceil, cos as _m_cos, cosh as _m_cosh, > exp as _m_exp, fabs as _m_fabs, floor as _m_floor, > fmod as _m_fmod, frexp as _m_frexp, hypot as _m_hypot, > ldexp as _m_ldexp, log as _m_log, log10 as _m_log10, > modf as _m_modf, sin as _m_sin, sinh as _m_sinh, > sqrt as _m_sqrt, tan as _m_tan, tanh as _m_tanh) > def ceil(x): > try: return _m_ceil(x) > except TypeError: return _n_ceil(x) > def cos(x): > try: return _m_cos(x) > except TypeError: return _n_cos(x) > def cosh(x): > try: return _m_cosh(x) > except TypeError: return _n_cosh(x) > def exp(x): > try: return _m_exp(x) > except TypeError: return _n_exp(x) > def fabs(x): > try: return _m_fabs(x) > except TypeError: return _n_fabs(x) > def floor(x): > try: return _m_floor(x) > except TypeError: return _n_floor(x) > def fmod(x): > try: return _m_fmod(x) > except TypeError: return _n_fmod(x) > def frexp(x): > try: return _m_frexp(x) > except TypeError: return _n_frexp(x) > def hypot(x): > try: return _m_hypot(x) > except TypeError: return _n_hypot(x) > def ldexp(x): > try: return _m_ldexp(x) > except TypeError: return _n_ldexp(x) > def log(x): > try: return _m_log(x) > except TypeError: return _n_log(x) > def log10(x): > try: return _m_log10(x) > except TypeError: return _n_log10(x) > def modf(x): > try: return _m_modf(x) > except TypeError: return _n_modf(x) > def sin(x): > try: return _m_sin(x) > except TypeError: return _n_sin(x) > def sinh(x): > try: return _m_sinh(x) > except TypeError: return _n_sinh(x) > def sqrt(x): > try: return _m_sqrt(x) > except TypeError: return _n_sqrt(x) > def tan(x): > try: return _m_tan(x) > except TypeError: return _n_tan(x) > def tanh(x): > try: return _m_tanh(x) > except TypeError: return _n_tanh(x) > > Scott David Daniels > Scott.Daniels@... > > >  > This SF.net email is sponsored by: Microsoft > Defy all challenges. Microsoft(R) Visual Studio 2005. > http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/ > _______________________________________________ > Visualpythonusers mailing list > Visualpythonusers@... > https://lists.sourceforge.net/lists/listinfo/visualpythonusers > 
From: Lenore Horner <lhorner@si...>  20071229 20:22:08

Try http://www.wiili.org/index.php/Main_Page. Lenore Horner On Dec 29, 2007, at 11:39 AM, John Brawley wrote: > >  Original Message  > From: <visualpythonusersrequest@...> >> Message: 6 >> Date: Fri, 28 Dec 2007 01:35:49 0500 >> From: Bruce Sherwood <Bruce_Sherwood@...> >> Subject: [Visualpythonusers] Wii interface >> >> A friend sent me the following link to very interesting work on using >> the Wii controller with a regular computer, in highly innovative >> ways: >> >> http://www.cs.cmu.edu/~johnny/projects/wii/ >> >> Bruce Sherwood > > Hi Bruce; > This link appears not to work. Backediting the URL to the .edu > domain > gets a page with many broken image links.... > I was interested in reading on the Wii controller linkedto a > computer, > but is there a way to get _to_ that article? > > Peace > JB > jb@... > Web: http://tetrahedraverse.com > > > >  >  > This SF.net email is sponsored by: Microsoft > Defy all challenges. Microsoft(R) Visual Studio 2005. > http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/ > _______________________________________________ > Visualpythonusers mailing list > Visualpythonusers@... > https://lists.sourceforge.net/lists/listinfo/visualpythonusers 
From: Ron Adam <rrr@ro...>  20071229 20:19:18

Bruce Sherwood wrote: > Questions were asked recently about looking outward from the origin (or > other location) and rotating the view of the surrounding scene. As an > example of this kind of viewing, see look_around.py in the contributed > section of vpython.org. > > Bruce Sherwood Here's a fun demo that uses rotating and spin I meant to submit some time ago and never did. Enjoy, Ron Adam 
From: Bruce Sherwood <Bruce_S<herwood@nc...>  20071229 18:04:21

It worked yesterday.... If you search YouTube for johnny lee wii you'll find the presentations. I also found that procrastineering.com will get you to one of Johnny Lee's sites. Bruce Sherwood John Brawley wrote: >  Original Message  > From: <visualpythonusersrequest@...> > >> Message: 6 >> Date: Fri, 28 Dec 2007 01:35:49 0500 >> From: Bruce Sherwood <Bruce_Sherwood@...> >> Subject: [Visualpythonusers] Wii interface >> >> A friend sent me the following link to very interesting work on using >> the Wii controller with a regular computer, in highly innovative ways: >> >> http://www.cs.cmu.edu/~johnny/projects/wii/ >> >> Bruce Sherwood >> > > Hi Bruce; > This link appears not to work. Backediting the URL to the .edu domain > gets a page with many broken image links.... > I was interested in reading on the Wii controller linkedto a computer, > but is there a way to get _to_ that article? > > Peace > JB > jb@... > Web: http://tetrahedraverse.com > > > 
From: John Brawley <jb@te...>  20071229 17:43:31

 Original Message  From: <visualpythonusersrequest@...> > Message: 6 > Date: Fri, 28 Dec 2007 01:35:49 0500 > From: Bruce Sherwood <Bruce_Sherwood@...> > Subject: [Visualpythonusers] Wii interface > > A friend sent me the following link to very interesting work on using > the Wii controller with a regular computer, in highly innovative ways: > > http://www.cs.cmu.edu/~johnny/projects/wii/ > > Bruce Sherwood Hi Bruce; This link appears not to work. Backediting the URL to the .edu domain gets a page with many broken image links.... I was interested in reading on the Wii controller linkedto a computer, but is there a way to get _to_ that article? Peace JB jb@... Web: http://tetrahedraverse.com 
From: Bruce Sherwood <Bruce_S<herwood@nc...>  20071229 06:21:49

Questions were asked recently about looking outward from the origin (or other location) and rotating the view of the surrounding scene. As an example of this kind of viewing, see look_around.py in the contributed section of vpython.org. Bruce Sherwood 
From: Bruce Sherwood <Bruce_S<herwood@nc...>  20071229 02:19:59

Thanks for the suggestion. I'll look into this workaround. Bruce Sherwood Scott David Daniels wrote: > I (Scott David Daniels) wrote: > >> I'm not sure of the overhead here, but could something like this work? >> >> def sqrt(x): >> try: return math.sqrt(x) >> except TypeError: return numpy.sqrt(x) >> > > If it "kinda" works, the following addition to __init__ should work: > > from numpy import (ceil as _n_ceil, cos as _n_cos, cosh as _n_cosh, > exp as _n_exp, fabs as _n_fabs, floor as _n_floor, > fmod as _n_fmod, frexp as _n_frexp, hypot as _n_hypot, > ldexp as _n_ldexp, log as _n_log, log10 as _n_log10, > modf as _n_modf, sin as _n_sin, sinh as _n_sinh, > sqrt as _n_sqrt, tan as _n_tan, tanh as _n_tanh) > from math import (ceil as _m_ceil, cos as _m_cos, cosh as _m_cosh, > exp as _m_exp, fabs as _m_fabs, floor as _m_floor, > fmod as _m_fmod, frexp as _m_frexp, hypot as _m_hypot, > ldexp as _m_ldexp, log as _m_log, log10 as _m_log10, > modf as _m_modf, sin as _m_sin, sinh as _m_sinh, > sqrt as _m_sqrt, tan as _m_tan, tanh as _m_tanh) > def ceil(x): > try: return _m_ceil(x) > except TypeError: return _n_ceil(x) > def cos(x): > try: return _m_cos(x) > except TypeError: return _n_cos(x) > def cosh(x): > try: return _m_cosh(x) > except TypeError: return _n_cosh(x) > def exp(x): > try: return _m_exp(x) > except TypeError: return _n_exp(x) > def fabs(x): > try: return _m_fabs(x) > except TypeError: return _n_fabs(x) > def floor(x): > try: return _m_floor(x) > except TypeError: return _n_floor(x) > def fmod(x): > try: return _m_fmod(x) > except TypeError: return _n_fmod(x) > def frexp(x): > try: return _m_frexp(x) > except TypeError: return _n_frexp(x) > def hypot(x): > try: return _m_hypot(x) > except TypeError: return _n_hypot(x) > def ldexp(x): > try: return _m_ldexp(x) > except TypeError: return _n_ldexp(x) > def log(x): > try: return _m_log(x) > except TypeError: return _n_log(x) > def log10(x): > try: return _m_log10(x) > except TypeError: return _n_log10(x) > def modf(x): > try: return _m_modf(x) > except TypeError: return _n_modf(x) > def sin(x): > try: return _m_sin(x) > except TypeError: return _n_sin(x) > def sinh(x): > try: return _m_sinh(x) > except TypeError: return _n_sinh(x) > def sqrt(x): > try: return _m_sqrt(x) > except TypeError: return _n_sqrt(x) > def tan(x): > try: return _m_tan(x) > except TypeError: return _n_tan(x) > def tanh(x): > try: return _m_tanh(x) > except TypeError: return _n_tanh(x) > > Scott David Daniels > Scott.Daniels@... > > >  > This SF.net email is sponsored by: Microsoft > Defy all challenges. Microsoft(R) Visual Studio 2005. > http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/ > _______________________________________________ > Visualpythonusers mailing list > Visualpythonusers@... > https://lists.sourceforge.net/lists/listinfo/visualpythonusers > 
From: Bruce Sherwood <Bruce_S<herwood@nc...>  20071228 06:36:53

Thanks much for the report. Bruce Sherwood Frédéric Mantegazza wrote: > Hi, > > I found another problem with vpython 4, under linux: when I set the display > visible attribute to False, then set it again to True, only a few objects > are visible again. > > This only occurs under linux, not under windows. > > 
From: Bruce Sherwood <Bruce_S<herwood@nc...>  20071228 06:35:51

A friend sent me the following link to very interesting work on using the Wii controller with a regular computer, in highly innovative ways: http://www.cs.cmu.edu/~johnny/projects/wii/ Bruce Sherwood 
From:
<frederic.mantegazza@gb...>  20071227 21:28:04

Hi, I found another problem with vpython 4, under linux: when I set the display= =20 visible attribute to False, then set it again to True, only a few objects=20 are visible again. This only occurs under linux, not under windows. =2D=20 Fr=E9d=E9ric http://www.gbiloba.org 
From: Scott David Daniels <Scott.Daniels@Acm.Org>  20071227 17:06:16

I (Scott David Daniels) wrote: > I'm not sure of the overhead here, but could something like this work? > > def sqrt(x): > try: return math.sqrt(x) > except TypeError: return numpy.sqrt(x) If it "kinda" works, the following addition to __init__ should work: from numpy import (ceil as _n_ceil, cos as _n_cos, cosh as _n_cosh, exp as _n_exp, fabs as _n_fabs, floor as _n_floor, fmod as _n_fmod, frexp as _n_frexp, hypot as _n_hypot, ldexp as _n_ldexp, log as _n_log, log10 as _n_log10, modf as _n_modf, sin as _n_sin, sinh as _n_sinh, sqrt as _n_sqrt, tan as _n_tan, tanh as _n_tanh) from math import (ceil as _m_ceil, cos as _m_cos, cosh as _m_cosh, exp as _m_exp, fabs as _m_fabs, floor as _m_floor, fmod as _m_fmod, frexp as _m_frexp, hypot as _m_hypot, ldexp as _m_ldexp, log as _m_log, log10 as _m_log10, modf as _m_modf, sin as _m_sin, sinh as _m_sinh, sqrt as _m_sqrt, tan as _m_tan, tanh as _m_tanh) def ceil(x): try: return _m_ceil(x) except TypeError: return _n_ceil(x) def cos(x): try: return _m_cos(x) except TypeError: return _n_cos(x) def cosh(x): try: return _m_cosh(x) except TypeError: return _n_cosh(x) def exp(x): try: return _m_exp(x) except TypeError: return _n_exp(x) def fabs(x): try: return _m_fabs(x) except TypeError: return _n_fabs(x) def floor(x): try: return _m_floor(x) except TypeError: return _n_floor(x) def fmod(x): try: return _m_fmod(x) except TypeError: return _n_fmod(x) def frexp(x): try: return _m_frexp(x) except TypeError: return _n_frexp(x) def hypot(x): try: return _m_hypot(x) except TypeError: return _n_hypot(x) def ldexp(x): try: return _m_ldexp(x) except TypeError: return _n_ldexp(x) def log(x): try: return _m_log(x) except TypeError: return _n_log(x) def log10(x): try: return _m_log10(x) except TypeError: return _n_log10(x) def modf(x): try: return _m_modf(x) except TypeError: return _n_modf(x) def sin(x): try: return _m_sin(x) except TypeError: return _n_sin(x) def sinh(x): try: return _m_sinh(x) except TypeError: return _n_sinh(x) def sqrt(x): try: return _m_sqrt(x) except TypeError: return _n_sqrt(x) def tan(x): try: return _m_tan(x) except TypeError: return _n_tan(x) def tanh(x): try: return _m_tanh(x) except TypeError: return _n_tanh(x) Scott David Daniels Scott.Daniels@... 
From: Scott David Daniels <Scott.Daniels@Acm.Org>  20071227 16:34:07

Bruce Sherwood wrote: > I've already played with essentially this. In > sitepackages/visual/__init__.py we import math, then numpy, which means > that sqrt goes to numpy. If I reverse the order of these imports it does > indeed mean that we use math.sqrt, but this then breaks programs such as > gas.py where the argument of the sqrt is an array of vectors. What I > need is for sqrt(25) to be treated like 5, but also to be able to use > the array features of the numpy sqrt when the argument isn't a simple > scalar. I'm not sure of the overhead here, but could something like this work? def sqrt(x): try: return math.sqrt(x) except TypeError: return numpy.sqrt(x) Scott David Daniels Scott.Daniels@... 
From: Joel Kahn <jj2kk4@ya...>  20071227 14:24:19

Bruce Sherwood wrote: >Ideally it would be better to get a Wiilike >capability onto regular computers. I tend to agree. There are some folks at SchoolForge who are thinking along these general lines. For anyone who might be interested, here's a possible contact: James P. Kinney III jkinney@... Enjoy. Joel ____________________________________________________________________________________ Looking for last minute shopping deals? Find them fast with Yahoo! Search. http://tools.search.yahoo.com/newsearch/category.php?category=shopping 