A17 ==== The more I play with the example the more depressing it gets. Start > with floating point numbers but explicitely arbitrary-precision ones. In[1]:= > a=77617.00000000000000000000000000000; > b=33095.00000000000000000000000000000; In[3]:= > !(333.7500000000000000000000000000000 b^6 + a^2 ((11 a^2 > b^2 - > b^6 - 121 b^4 - 2)) + 5.500000000000000000000000000000 b^8 + > a/(2 > b)) Out[3]= > !((-4.78339168666055402578083604864320577443814`26.6715*^32)) In[4]:= > Accuracy[%] Out[4]= > -6 Due to the manual section 3.1.6: When you do calculations with arbitrary-precision numbers, as > discussed in the previous section, Mathematica always keeps track of > the precision of your results, and gives only those digits which are > known to be correct, given the precision of your input. When you do > calculations with machine-precision numbers, however, Mathematica > always gives you a machine[CapitalEth]precision result, whether or not all the > digits in the result can, in fact, be determined to be correct on the > basis of your input. Because I started with arbitrary-precision numbers Mathematica should display > only those digits that are correct, that is none. No, 26 digits are correct (check Precision instead of Accuracy to see this). You appear to be showing output in InputForm. If you use OutputForm or StandardForm only 26 digits will be shown. 32 Out[3]= -4.7833916866605540257808360 10 InputForm is showing more because it exposes bad digits as well as good ones. > To relax a bit, set a new input cell to StandardForm and type > 77617.000000000000000000000000000000000 Convert it to InputForm. You get > 77616.999999999999999999999999999999999999999999952771`37.9031 Convert back to StandardForm > 77616.99999999999999999999999999999999999999999976637`37.9031 Again to InputForm > 77616.99999999999999999999999999999999999999999963735`37.9031 Back to StandardForm > 77616.99999999999999999999999999999999999999999951376`37.9031 See what you can get if you have enough patience or a small program. PK Agreed, it's not very pretty. I am uncertain as to whether this indicates a bug in StandardForm or elsewhere in the underlying numerics code, and will defer to our numerics experts on that issue. My guess is it is a bug if only because it violates the spirit of IEEE arithmetic wherein floats that have integer values should be representable as such (or something to that effect). I will point out, however, that the two numbers in question are equal to the specified precision. Also it appears to be improved in our development kernel. Daniel Lichtblau Wolfram Research ==== The more I play with the example the more depressing it gets. Start with floating point numbers but explicitely arbitrary-precision ones. In[1]:= a=77617.00000000000000000000000000000; b=33095.00000000000000000000000000000; In[3]:= !(333.7500000000000000000000000000000 b^6 + a^2 ((11 a^2 b^2 - b^6 - 121 b^4 - 2)) + 5.500000000000000000000000000000 b^8 + a/(2 b)) Out[3]= !((-4.78339168666055402578083604864320577443814`26.6715*^32)) In[4]:= Accuracy[%] Out[4]= -6 Due to the manual section 3.1.6: When you do calculations with arbitrary-precision numbers, as discussed in the previous section, Mathematica always keeps track of the precision of your results, and gives only those digits which are known to be correct, given the precision of your input. When you do calculations with machine-precision numbers, however, Mathematica always gives you a machine[CapitalEth]precision result, whether or not all the digits in the result can, in fact, be determined to be correct on the basis of your input. Because I started with arbitrary-precision numbers Mathematica should display only those digits that are correct, that is none. To relax a bit, set a new input cell to StandardForm and type 77617.000000000000000000000000000000000 Convert it to InputForm. You get 77616.999999999999999999999999999999999999999999952771`37.9031 Convert back to StandardForm 77616.99999999999999999999999999999999999999999976637`37.9031 Again to InputForm 77616.99999999999999999999999999999999999999999963735`37.9031 Back to StandardForm 77616.99999999999999999999999999999999999999999951376`37.9031 See what you can get if you have enough patience or a small program. PK ==== > The more I play with the example the more depressing it gets. Start > with floating point numbers but explicitely arbitrary-precision ones. In[1]:= > a=77617.00000000000000000000000000000; > b=33095.00000000000000000000000000000; In[3]:= > !(333.7500000000000000000000000000000 b^6 + a^2 ((11 a^2 > b^2 - > b^6 - 121 b^4 - 2)) + 5.500000000000000000000000000000 b^8 + > a/(2 > b)) Out[3]= > !((-4.78339168666055402578083604864320577443814`26.6715*^32)) In[4]:= > Accuracy[%] Out[4]= > -6 Due to the manual section 3.1.6: When you do calculations with arbitrary-precision numbers, as > discussed in the previous section, Mathematica always keeps track of > the precision of your results, and gives only those digits which are > known to be correct, given the precision of your input. When you do > calculations with machine-precision numbers, however, Mathematica > always gives you a machine[CapitalEth]precision result, whether or not all the > digits in the result can, in fact, be determined to be correct on the > basis of your input. Because I started with arbitrary-precision numbers Mathematica should display > only those digits that are correct, that is none. I retract the above comment. I did not notice that was an error in the input. b=33095.00000000000000000000000000000 intstead of intended b=33096.00000000000000000000000000000 I am sorry for the mistake. PK > To relax a bit, set a new input cell to StandardForm and type > 77617.000000000000000000000000000000000 Convert it to InputForm. You get > 77616.999999999999999999999999999999999999999999952771`37.9031 Convert back to StandardForm > 77616.99999999999999999999999999999999999999999976637`37.9031 Again to InputForm > 77616.99999999999999999999999999999999999999999963735`37.9031 Back to StandardForm > 77616.99999999999999999999999999999999999999999951376`37.9031 See what you can get if you have enough patience or a small program. PK ==== > The last part of my message you are quoting was completely wrong, as > was pointed out by Allan Hayes. Mathematica does not track precision of > machine arithmetic computations. In order for Mathematica to give > reliable information about the precision of a computation you have to > explicitly set the precision of all the numerical quantities. Your own example at the bottom simply shows you have not understood the > evaluation mechanism of Mathematica. Just opposite, thanks to you and other participants, I completely understood it. SetAccuracy just takes anything and calls it accurate. This behavior is useless if not stupid. It was apparently intended by Mathematica developers but that doesn't make it right. On a side note, I hate the argument It is descibed in the manual, therefore it is correct. Legal doesn't mean right. Besides there is no supreme court here to overrule some stupid law. :-) PK [...] ==== >Dear Colleagues, > >I calculated: > >Sum[1/Prime[n], {n, 15000}] // N > >Result: 2.74716 > >Now I wonder if this sum will converge or keep on growing, albeit very >slowly. > > >Matthias Bode >Sal. Oppenheim jr. & Cie. KGaA >Koenigsberger Strasse 29 >D-60487 Frankfurt am Main >GERMANY >Mobile: +49(0)172 6 74 95 77 >Internet: http://www.oppenheim.de > > > The serie is divergent! I suggest you to look at this beautiful introduction to primes distribution http://www.maths.ex.ac.uk/%7Emwatkins/zeta/vardi.html Bye, rob Roberto Brambilla CESI Via Rubattino 54 20134 Milano tel +39.02.2125.5875 fax +39.02.2125.5492 rlbrambilla@cesi.it ==== > I've been looking over the file and directory manipulation functions in Mathematica > 4.1, and I'm not finding good examples of how to test for the existence of > a file or directory before I attempt to create, access, or delete it. Are > there any good examples of this somewhere? > > STH > > Steven, Directory[] returns the current directory $Path returns the directories in your path where files can be found. SetDirectory[] changes to the specified directory and makes it the current directory. FileNames[] returns a list of all the file names (text documents, picture documents etc) and subdirectory (folder) names in the current directory. Since FileNames returns a list of elements, you can use all sorts of tests to see if a file you're looking for is in a said directory or not or whether it is a subdirectory or not. I hope that this will get you started. Yas ==== has anybody tried to modify the classes.m package in the way, it would be possible to have several superclasses? Oleg. ==== What does this page say, auf Englisch? I only pretend to understand German. http://www.mertig.com/neu/HTMLLinks/index_6.html STH ==== The sum diverges. See Elementary Number Theory, 5th edition by David M. Burton, pages 355-356. -----Original Message----- Sal. Oppenheim jr. & Cie. KGaA Koenigsberger Strasse 29 D-60487 Frankfurt am Main GERMANY Mobile: +49(0)172 6 74 95 77 Internet: http://www.oppenheim.de ==== Technical support has responded to my query. They say that one of the simplifications that Mathematica does when using Simplify is to Factor the expression, and factoring an expression consisting of inexact numbers leads to the type of behavior I observed. They stated that changing the behavior of Simplify to avoid the problems I noticed would make Simplify less capable, and that the majority of users would prefer to have Simplify behave the way it currently does. Of course, that doesn't answer the question about why the number of terms in the expression would cause the coefficients to go from rational to inexact to rational again. At any rate, I have another lesson learned. When using Simplify, check the result if you are mixing infinite precision and inexact numbers, as the result may not be what you wanted. In the past I always assumed that the result of using Simplify on an expression produced a result equivalent to the original expression, but now I discover that this is not true. Carl Woll Physics Dept U of Washington ----- Original Message ----- > {i, > n}]], x[1]] > > Now lets try CW for the first 100 values of n: > > > In[30]:= > Table[CW[n], {n, 100}] > > Out[30]= > {1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, > 0.5`12.3085, 0.5`12.0074, 0.5`11.7064, 0.5`11.4054, > 0.5`11.1043, 0.5`10.8033, 0.5`10.5023, 0.5`10.2012, > 0.5`9.9002, 0.5`9.5992, 0.5`9.2982, 0.5`8.9971, > 0.5`8.6961, 0.5`8.3951, 0.5`8.094, 0.5`7.793, 0.5`7.492, > 0.5`7.1909, 0.5`6.8899, 0.5`6.5889, 0.5`6.2879, > 0.5`5.9868, 0.5`5.6858, 0.5`5.3848, 0.5`5.0837, > 0.5`4.7827, 0.5`4.4817, 0.5`4.1806, 0.5`3.8796, > 0.5`3.5786, 0.5`3.2776, 0.5`2.9765, 0.5`2.6755, > 0.5`2.3745, 0.5`2.3745, 0.5`1.7724, 0.5`1.7724, > 0.5`1.1703, 0.5`1.1703, 0.5`0.5683, 0``0.1423, 0``0.1423, > 0``0.1423, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, > 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, > 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, > 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, > 1/2, 1/2, 1/2} > > In[31]:= Map[Length,Split[#]] > > Out[31]= > {12,43,45} > > This is indeed curious.The problem seems to occur for values between 13 > and 55 and then go away (for good???) At first I thought it maybe in > some fascinating way related to some properties of the integer n, but > now I am not sure. It certainly worth a careful examination. I hope > whoever discovers the cause of this will let us know. > > Andrzej > > Andrzej Kozlowski > Yokohama, Japan > http://www.mimuw.edu.pl/~akoz/ > http://platon.c.u-tokyo.ac.jp/andrzej/ > > > > To Technical Support and the Mathematica User community, > > I'm writing to report what I consider to be a bug. First, I want to > show a > simplified example of the problem. Consider the following expression: > > expr=0.22 + x[0] + (3*(-0.16+ x[1]))/4 + (9*(0.546 + x[2]))/16; > > When simplified I expected to get some real number plus > x[0]+3x[1]/4+9x[2]/16, but instead I get the following: > > Simplify[expr] > 0.407125 + x[0] + 0.75 x[1] + 0.5625 x[2] > > As you can see, for some reason Mathematica converted the fractions > 3/4 and > 9/16 to real machine numbers. I consider this to be a bug. > > Now, for an example more representative of the situation that I've been > coming across. > > expr12 = 1.001`17 + Sum[(x[i] - 1.001`17)/2^i, {i, 12}]; > expr13 = 1.001`17 + Sum[(x[i] - 1.001`17)/2^i, {i, 13}]; > expr55 = 1.001`17 + Sum[(x[i] - 1.001`17)/2^i, {i, 55}]; > > As you can see, I have replaced the real numbers by extended precision > numbers. The simplified example above demonstrates that the problem > exists > when using machine numbers. Now, we'll see what happens when we use > arbitrary precision numbers. First, let's simplify the expression with > 12 > terms. > > Simplify[expr12] > (1.0010000000000 + 2048 x[1] + 1024 x[2] + 512 x[3] + 256 x[4] + 128 > x[5] + > > 64 x[6] + 32 x[7] + 16 x[8] + 8 x[9] + 4 x[10] + 2 x[11] + x[12]) > / 4096 > > As you can see, a sum with 12 terms upon simplification has > coefficients > which are still integers as they should be. However, increasing the > number > of terms to 13 yields > > Simplify[expr13] > 0.0001221923828125 + 0.500000000000 x[1] + 0.250000000000 x[2] + > > 0.1250000000000 x[3] + 0.0625000000000 x[4] + 0.0312500000000 x[5] + > > 0.01562500000000 x[6] + 0.00781250000000 x[7] + 0.00390625000000 > x[8] + > > 0.001953125000000 x[9] + 0.000976562500000 x[10] + 0.000488281250000 > x[11] > + > > 0.000244140625000 x[12] + 0.0001220703125000 x[13] > > Now, all of the coefficients are converted to real numbers, > replicating the > bug from the simplified example. Finally, let's see what happens when > we > have 55 terms. Rather than putting the resulting expression here, I > will > just leave it at the end of the post. The result though is somewhat > surprising. Each of the coefficients of the x[i] are again real > numbers, but > now their precision is only 0! The proper result of course is the sum > of > some real number (with a precision close to 0 due to numerical > cancellation) > and an expression consisting of rational numbers multiplied by x[i]. > The > loss of precision of the coefficients of the x[i] is precisely what > occurred > to me. Of course, in this simple example, simply using Expand instead > of > Simplify produces the expected result, and is my workaround. I hope you > agree with me that this is a bug, and one that Wolfram needs to > correct. > > Carl Woll > Physics Dept > U of Washington > > Simplify[expr55] > -16 -1 -1 -1 > 0. 10 + 0. x[1] + 0. x[2] + 0. 10 x[3] + 0. 10 x[4] + 0. 10 > x[5] + > > -2 -2 -2 -3 -3 > 0. 10 x[6] + 0. 10 x[7] + 0. 10 x[8] + 0. 10 x[9] + 0. 10 > x[10] > + > > -3 -3 -4 -4 > -4 > 0. 10 x[11] + 0. 10 x[12] + 0. 10 x[13] + 0. 10 x[14] + 0. 10 > x[15] + > > -5 -5 -5 -6 > -6 > 0. 10 x[16] + 0. 10 x[17] + 0. 10 x[18] + 0. 10 x[19] + 0. 10 > x[20] + > > -6 -6 -7 -7 > -7 > 0. 10 x[21] + 0. 10 x[22] + 0. 10 x[23] + 0. 10 x[24] + 0. 10 > x[25] + > > -8 -8 -8 -9 > -9 > 0. 10 x[26] + 0. 10 x[27] + 0. 10 x[28] + 0. 10 x[29] + 0. 10 > x[30] + > > -9 -9 -10 -10 > 0. 10 x[31] + 0. 10 x[32] + 0. 10 x[33] + 0. 10 x[34] + > > -10 -11 -11 -11 > 0. 10 x[35] + 0. 10 x[36] + 0. 10 x[37] + 0. 10 x[38] + > > -12 -12 -12 -12 > 0. 10 x[39] + 0. 10 x[40] + 0. 10 x[41] + 0. 10 x[42] + > > -13 -13 -13 -14 > 0. 10 x[43] + 0. 10 x[44] + 0. 10 x[45] + 0. 10 x[46] + > > -14 -14 -15 -15 > 0. 10 x[47] + 0. 10 x[48] + 0. 10 x[49] + 0. 10 x[50] + > > -15 -15 -16 -16 > - > 16 > 0. 10 x[51] + 0. 10 x[52] + 0. 10 x[53] + 0. 10 x[54] + > 0. 10 > x[55] > > > > > > > > ==== Dear Carl You have discovered what is perhaps a bug but maybe something even mor einteresting . However, I think you stopped your investigation a little prematurely. Here is a function that just computes the coefficient of x[1] in your Simplified expression for various values of n: CW[n_] := Coefficient[Simplify[1.001`17 + Sum[(x[i] - 1.001`17)/2^i, {i, n}]], x[1]] Now lets try CW for the first 100 values of n: In[30]:= Table[CW[n], {n, 100}] Out[30]= {1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 0.5`12.3085, 0.5`12.0074, 0.5`11.7064, 0.5`11.4054, 0.5`11.1043, 0.5`10.8033, 0.5`10.5023, 0.5`10.2012, 0.5`9.9002, 0.5`9.5992, 0.5`9.2982, 0.5`8.9971, 0.5`8.6961, 0.5`8.3951, 0.5`8.094, 0.5`7.793, 0.5`7.492, 0.5`7.1909, 0.5`6.8899, 0.5`6.5889, 0.5`6.2879, 0.5`5.9868, 0.5`5.6858, 0.5`5.3848, 0.5`5.0837, 0.5`4.7827, 0.5`4.4817, 0.5`4.1806, 0.5`3.8796, 0.5`3.5786, 0.5`3.2776, 0.5`2.9765, 0.5`2.6755, 0.5`2.3745, 0.5`2.3745, 0.5`1.7724, 0.5`1.7724, 0.5`1.1703, 0.5`1.1703, 0.5`0.5683, 0``0.1423, 0``0.1423, 0``0.1423, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2} In[31]:= Map[Length,Split[#]] Out[31]= {12,43,45} This is indeed curious.The problem seems to occur for values between 13 and 55 and then go away (for good???) At first I thought it maybe in some fascinating way related to some properties of the integer n, but now I am not sure. It certainly worth a careful examination. I hope whoever discovers the cause of this will let us know. Andrzej Andrzej Kozlowski Yokohama, Japan http://www.mimuw.edu.pl/~akoz/ http://platon.c.u-tokyo.ac.jp/andrzej/ > To Technical Support and the Mathematica User community, > > I'm writing to report what I consider to be a bug. First, I want to > show a > simplified example of the problem. Consider the following expression: > > expr=0.22 + x[0] + (3*(-0.16+ x[1]))/4 + (9*(0.546 + x[2]))/16; > > When simplified I expected to get some real number plus > x[0]+3x[1]/4+9x[2]/16, but instead I get the following: > > Simplify[expr] > 0.407125 + x[0] + 0.75 x[1] + 0.5625 x[2] > > As you can see, for some reason Mathematica converted the fractions > 3/4 and > 9/16 to real machine numbers. I consider this to be a bug. > > Now, for an example more representative of the situation that I've been > coming across. > > expr12 = 1.001`17 + Sum[(x[i] - 1.001`17)/2^i, {i, 12}]; > expr13 = 1.001`17 + Sum[(x[i] - 1.001`17)/2^i, {i, 13}]; > expr55 = 1.001`17 + Sum[(x[i] - 1.001`17)/2^i, {i, 55}]; > > As you can see, I have replaced the real numbers by extended precision > numbers. The simplified example above demonstrates that the problem > exists > when using machine numbers. Now, we'll see what happens when we use > arbitrary precision numbers. First, let's simplify the expression with > 12 > terms. > > Simplify[expr12] > (1.0010000000000 + 2048 x[1] + 1024 x[2] + 512 x[3] + 256 x[4] + 128 > x[5] + > > 64 x[6] + 32 x[7] + 16 x[8] + 8 x[9] + 4 x[10] + 2 x[11] + x[12]) > / 4096 > > As you can see, a sum with 12 terms upon simplification has > coefficients > which are still integers as they should be. However, increasing the > number > of terms to 13 yields > > Simplify[expr13] > 0.0001221923828125 + 0.500000000000 x[1] + 0.250000000000 x[2] + > > 0.1250000000000 x[3] + 0.0625000000000 x[4] + 0.0312500000000 x[5] + > > 0.01562500000000 x[6] + 0.00781250000000 x[7] + 0.00390625000000 > x[8] + > > 0.001953125000000 x[9] + 0.000976562500000 x[10] + 0.000488281250000 > x[11] > + > > 0.000244140625000 x[12] + 0.0001220703125000 x[13] > > Now, all of the coefficients are converted to real numbers, > replicating the > bug from the simplified example. Finally, let's see what happens when > we > have 55 terms. Rather than putting the resulting expression here, I > will > just leave it at the end of the post. The result though is somewhat > surprising. Each of the coefficients of the x[i] are again real > numbers, but > now their precision is only 0! The proper result of course is the sum > of > some real number (with a precision close to 0 due to numerical > cancellation) > and an expression consisting of rational numbers multiplied by x[i]. > The > loss of precision of the coefficients of the x[i] is precisely what > occurred > to me. Of course, in this simple example, simply using Expand instead > of > Simplify produces the expected result, and is my workaround. I hope you > agree with me that this is a bug, and one that Wolfram needs to > correct. > > Carl Woll > Physics Dept > U of Washington > > Simplify[expr55] > -16 -1 -1 -1 > 0. 10 + 0. x[1] + 0. x[2] + 0. 10 x[3] + 0. 10 x[4] + 0. 10 > x[5] + > > -2 -2 -2 -3 -3 > 0. 10 x[6] + 0. 10 x[7] + 0. 10 x[8] + 0. 10 x[9] + 0. 10 > x[10] > + > > -3 -3 -4 -4 > -4 > 0. 10 x[11] + 0. 10 x[12] + 0. 10 x[13] + 0. 10 x[14] + 0. 10 > x[15] + > > -5 -5 -5 -6 > -6 > 0. 10 x[16] + 0. 10 x[17] + 0. 10 x[18] + 0. 10 x[19] + 0. 10 > x[20] + > > -6 -6 -7 -7 > -7 > 0. 10 x[21] + 0. 10 x[22] + 0. 10 x[23] + 0. 10 x[24] + 0. 10 > x[25] + > > -8 -8 -8 -9 > -9 > 0. 10 x[26] + 0. 10 x[27] + 0. 10 x[28] + 0. 10 x[29] + 0. 10 > x[30] + > > -9 -9 -10 -10 > 0. 10 x[31] + 0. 10 x[32] + 0. 10 x[33] + 0. 10 x[34] + > > -10 -11 -11 -11 > 0. 10 x[35] + 0. 10 x[36] + 0. 10 x[37] + 0. 10 x[38] + > > -12 -12 -12 -12 > 0. 10 x[39] + 0. 10 x[40] + 0. 10 x[41] + 0. 10 x[42] + > > -13 -13 -13 -14 > 0. 10 x[43] + 0. 10 x[44] + 0. 10 x[45] + 0. 10 x[46] + > > -14 -14 -15 -15 > 0. 10 x[47] + 0. 10 x[48] + 0. 10 x[49] + 0. 10 x[50] + > > -15 -15 -16 -16 > - > 16 > 0. 10 x[51] + 0. 10 x[52] + 0. 10 x[53] + 0. 10 x[54] + > 0. 10 > x[55] > > > > > > > ==== I think, for input of that many numbers (and other inputs), I might use an input file that has textual names or descriptions in the first ten or twenty columns, followed by values starting at a fixed column after that. Mathematica or Java could easily read inputs from that, and a human could read it as well. If you're concerned that a human might jumble the file format -- accidentally deleting lines, etc. -- a program could key on the names or descriptions rather than trusting them to be in correct order, and point out missing values. A strategy like that allows you to start with a previous input file (not from scratch) and change only what needs to change. Also, Mathematica 4.2 adds XML support to the picture, and that might be useful. Bobby -----Original Message----- > > I agree with Mr. Kuska, that the system Mr Nagesh describes is not > userfriendly. But I think, the suggestions of Mr. Kuska do not make it more > userfriendly, rather the opposite is true. > > Mr. Nagesh asks > > Is any body here have expertise or information about the capability of > Mathematica as a system simulation tool? > Mr. Kuska answers: > Since the most system simulation tools are simply solving a system of > ordinary differntial equations it is simple to do this with NDSolve[]. > > My comment: > > That is: He sees the simulation system merely as a set of differential > equations. > > hmm, since the original poster write > > My refrigeration system simulation package is likely to have > approximately 60 First order Differential equations. > > it seems not completly wrong to assume that the system consists of > of ode's .. > Yout should not ignore the word merely. It is not enough to have a set 60 differential equations and a set of 200-250 numbers. That is not simulation system, which can be used by users with the exception, perhaps, of the programmer of the system himself. How does e.g. the user know what meaning a number in the set has, ought he count the numbers from the beginning? Your nice command shows only, if there is an input, which is not a number. But I think the user would like to know, which of the 200 elements are not numbers. The only good of your command is, that it looks nice and shows your knowledge! > > The question of Mr. Nagesh: > > My 4th Objective:- How can I program the check for correctness of the > input values supplied by the package user ? > The answer of Mr. Kuska is: > And @@ (NumericQ /@ {aListOfAllYourNumericParameters}) > > My comment: > > This is a nice command and shows the knowledge of Mr.Kuska. But does Mr. > Nagesh understand it and is it sufficient to check, if all inputs are > numerical? > > It seems you have a deeper knowlege about the things that Mr. Nagesh > understand. You know him personally ? It is not very polite to > make speculations *what* a other person understand. > > And no it is not sufficent to check that all parameters are numbers. > Typical paramters described by intervals, where the assumptions of > a model are valid. But for this checks one needs more knowlege > about the meaning of the parameters. And one needs the knowlege about > the differntial equations, to find out the eigenvalues of the jacobian > ... > > > Additionally I think, it is not userfriendly to see the input merely as a > set of 200-250 numbers. > > My suggestion is, that JLink is used, a suggestion Mr. Kusk takes into > consideration, too. > > That will be fast as lightning ! > > > But further I suggest, that classes are defined in Java, which represent the > parts of the system. > > That is notable nonsense! When the differntial equations should be > solved with Mathematica, the parts can't be Java classes. Mathematica's > NDSolve[] need a explicit expression to integrate the equations. That's not nonsense, the Mathematica program does not fetch the classes but the numbers in the classes (or better in the objects). in the Java classes in textform. They can then be fetched from the Mathematica program and transformed into expressions by the Command ToExpression. The aim is, to have a clear separation of the system into components, which are manageable and understandable. > > OK you can call a Java class member from Mathematica but this will > be incredible slow when the right hand side is evaluated 200-300 > times and every evaluation make several callbacks to the Java source. > Event handler of the Java main program (without some modification in > the event loop) while it is evaluating an other command. My idea is to fetch the values once from the Java objects at the beginning. 200-250 numbers is not so much.. > > > Constructors of the classes should build objects with default values. > > That's a great idea. If a simulation run should be documented, one > always > need the full listing of the Java source to find the actual parameter > settings. That is not my opinion. I think not every user of the simulation system should have to know Java and Mathematica. The user must look for the values in the objects. And the values are in the objects, if they come from the constructor or from the graphical user interface. I think, there should be listings of the objects including names of the variables. In the objects the values are in an meaningful environment. > > Graphical user interfaces > should give the opportunity to change the data fields in the objects and > check the input for correctness. > > *and* what has a GUI for 200-250 variables to do with Mathematica ? > BTW one has typical much less variables because many parameters > are fixed and it make no sense to change, for example, material > constants of materials that can't exchanged > > > The system should give the opportunity, to store the objects on harddisk > (serialization). > > accessed directly. > > > Can you be so kind, to explain *how* your posting help a person that > ask How can I build a simulation system with Mathematica ? > > You *can* say Don't use Mathematica, use Java! but this has nothing > to do with the question or with my reply. It is you, who proposes to solve the problem with C/C++ and not to use Mathematica (see below!) My point of view is: Use Mathematica, for what Mathemtica is good, and Java, for what Java is good. Mathematica is not so good as Java for data entry and Java is better than Mathematica to represent the simulation system (by objects). > > But I still would suggest to use C/C++ and a numerical > ode-solver, make a fancy GUI/Script > interface and don't use Mathematica for such a simple task. > The ode-solver is the smallest part of such a simulation system. > > Jens > > > > > My name is Nagesh and pursuing research studies in Refrigeration. At > present I am writing a Dynamic Refrigeration System Simulation Package. > I > am using Mathematica as a programming language for the same since last > one > year. I don't have any programming experience before this. I have > following > querries:- > 1. Is any body here have expertise or information about the capability > of > Mathematica as a system simulation tool? > > Since the most system simulation tools are simply solving a system of > ordinary differntial equations it is simple to do this with NDSolve[]. > > 2. Is is possible to program a user friendly interface for my system > simulation package with Mathematica or I have to use some other > software? > > Write a MathLink or J/Link frontend that launch the kernel. But you > should keep > in mind that the user interface is typical 80-90 % of your code. > If you just whant to solve some ode's it is probably easyer to > include one of the excelent ode-solvers from netlib in your C-code > than to call Mathematica to do that. As long as you dont wish to change > the ode's very often (than Mathematica is more flexible) you should > not use Mathematica. > > 3. My refrigeration system simulation package is likely to have > approximately 60 First order Differential equations. Is is possible to > solve these in Mathematica ? > > Sure. > If yes then can anybody here guide me about > this further. > > Write down the equations and call NDSolve[]. > > > I am explaining below in short about the objectives I want to fulfill > from > coding out of my main input file > > 1. Example from Main Input File ( this will contain about 200-250 > variables > which will be entered by the user of this package) > > This sounds like a *very* userfiendly interface ;-) > > > Below is examples of two variables entered into this file, which will be > used in other analysis files for further evaluation. > > 2. Example from other analysis file ( there will be about 20-25 other > such > component analysis files ) where the above mentioned variables from main > input file will be used for further evaluations:- > > Below is one example from this file explaining how the variables from > main > input file will be used in other files. > > I hope that this short information will be useful for guiding me to > solve > the following problems that I am facing. I am facing follwing problems > or > objectives:- > > 1. My 1st Objective:- The user of this package must be able to change > only > the value of the variable in the main input file but he must not be able > to > change the name of the variable itself. For example he must be able to > change the value of the variable but he must not be able to change > the > name of this variable itself. > Here our problem is how to achieve or program it so that our objective > will > be fullfilled. > > Options with defaulf values ? or something like > > {aParam,bParam}={ODEParameter1,ODEParameter2} /. > userRules /. > {ODEParameter1->1,ODEParameter2->2} > > > 2. My 2nd Objective:- How I can program the main input file so that it > will > be user friendly in terms of its visuals and satisfying the constraint > mentioned above in objective1. > > What is *userfiendly* in a file with 250 variables ??? > > > 3. My 3rd Objective:- How can I program the optional values for each > variable in the main input file ? so that there will be always a value > assigned to each variable listed in main input file whenever the user > opens > up this file. If user want to change the values of some variables then > he > can change them and run the simulation otherwise the simulation run will > be > done with optional values assigned to each variable in the input file. > > See above. > > > 4. My 4th Objective:- How can I program the check for correctness of the > input values supplied by the package user ? > > And @@ (NumericQ /@ {aListOfAllYourNumericParameters}) > > > Jens > > ==== hi > AFAIK, Mac OS is now BSD or something like that. That makes it almost > certain that it could support QT. As I pointed out in another post, I can > run the KDE on Windows XP. I haven't been in the trenches with the Qt > impression is, it really is 'code once, run everywhere'. i've checked the trolltech hp. qt fully supports the following OS: MS Windows 95/98/Me, NT4, 2000 and XP. Mac OS X. > This is one of the reasons I am such a Mozilla fan. Konqueror works quite > like. But Mozilla runs everywhere with more or less a uniform look and > feel. Yes, Mozilla is written with Gtk and not with Qt, but that just > shows that WRI has options. i'm not sure if it is allowed to create a closed-source product like the mathematica fronend based on a gpl'ed library like gtk. with qt you have the possibility to buy licenses for the commercial version of qt, allowing you to create closed-source apps. > I'm a KDE fan. I've used the KDE since it was in alpha 0.4. I remember > back when it would compile in a few minutes on a pentium II. Now it takes > several hours on a P4. i started with beta1 (if i remember correctly) - sure it is really big now, but i think kde is still far away from being bloated..... imagine the mathematica frontend being seamlessly integrated into the linux ui's look and feel.... > I've always hated motif. The file chooser simply stinks. And that's just a > start. the whole motif ui stinks....:-) gerald ************************************* Gerald Roth M@th Desktop Development ************************************* ==== > hi, moving the frontend over to QT would have some neat side effects: > consistent look & feel with the modern linux gui, themeability, source > antialiased > truetype fonts as QT supports Xrender and Xft (looks great - see KDE3). i > think all of those points are of value, but the most important might be > source compatibility. ONE frontend for MOST (or ALL) platforms - sounds > like a dream :-)) AFAIK, Mac OS is now BSD or something like that. That makes it almost certain that it could support QT. As I pointed out in another post, I can run the KDE on Windows XP. I haven't been in the trenches with the Qt impression is, it really is 'code once, run everywhere'. This is one of the reasons I am such a Mozilla fan. Konqueror works quite like. But Mozilla runs everywhere with more or less a uniform look and feel. Yes, Mozilla is written with Gtk and not with Qt, but that just shows that WRI has options. I'm a KDE fan. I've used the KDE since it was in alpha 0.4. I remember back when it would compile in a few minutes on a pentium II. Now it takes several hours on a P4. But if WRI wanted to go the Gtk route, they could achieve the same ends. I've always hated motif. The file chooser simply stinks. And that's just a start. gerald > STH ==== Can I solve this inequality with Mathematica? Log[x,a]+Log[a x,a]>0 I've tried all know, but I get get any good result. CeZaR ==== First thanks to all, and in particular Bobby Treat, for your help with > this question. The best solution was as follows: lst = ReadList[c:data.txt, {Number, Number}] > adjacenceMatrix[ > x:{{_, _}..}] := Module[{actors, events}, > {actors, events} = Union /@ Transpose[x]; > Array[If[MemberQ[x, {actors[[#1]], events[[#2]]}], 1, 0] & , > {Length[actors], Length[events]}]] a = adjacenceMatrix[lst]; > b = a . Transpose[a]; > c = b (1 - IdentityMatrix[Length[b]]) C is the desired symmetric matrix with off diagonal values of >=0, > indicating the number of times two actors participate in the same event. > The diagonal is set to 0. A few items in response to Bobby's message, below. While c is, in fact, > a huge matrix with lots of cells equal to zero, that is exactly how we > need it structured for our analysis and research question (not relevant > to the list, but I'd be happy to discuss off list). Processing time is > actually not too bad!! I'm running a PIII 900 with 512 SDRAM, and the > code ran a 177 x 3669 matrix in under 90 seconds. MatrixForm [c] > presented no problems in viewing in the front end, but then it's only > 177 x 177. > Tom ********************************************** > Thomas P. Moliterno > Graduate School of Management > University of California, Irvine > tmoliter@uci.edu > ********************************************** > [...] There are several ways to go about this and which is best will vary based on relative number of events vs. number of actors. Below I show three variations. The first is a minor recoding of the one above. The second iterates over all pairs of actors. The third looks at all events for common actors. I then show three examples. The first two methods have the advantage that they do not require that events be positive integers. With some extra work the third method could also get around this restriction. toAdjacency0[data:{{_, _}..}] := Module[ {actors, events, mat1, mat2}, {actors, events} = Union /@ Transpose[data]; mat1 = Array[If[MemberQ[data, {actors[[#1]], events[[#2]]}], 1, 0] & , {Length[actors], Length[events]}]; mat2 = mat1 . Transpose[mat1]; mat2 * (1-IdentityMatrix[Length[mat2]]) ] toAdjacency1[origdata_] := Module[ {data=Union[origdata], mat}, data = Map[Last, Split[data,#1[[1]]===#2[[1]]&], {2}]; mat = Table [If [j>k, Length[Intersection[data[[j]],data[[k]]]], 0], {j,Length[data]}, {k,Length[data]}]; mat+Transpose[mat] ] toAdjacency2[origdata_] := Module[ {data=Sort[Map[Reverse,Union[origdata]]], mat, len, event}, data = Map[Last, Split[data,#1[[1]]===#2[[1]]&], {2}]; dim = Length[Union[Flatten[data]]]; len = Length[data]; mat = Table[0, {dim}, {dim}]; Do [ event = data[[j]]; Do [ Do [ mat[[event[[m]],event[[k]]]] += 1; mat[[event[[k]],event[[m]]]] += 1, {m,k-1}], {k,Length[event]}], {j,len}]; mat ] data1 = Table[{Random[Integer,{1,1000}], Random[Integer,50]}, {10000}]; data2 = Table[{Random[Integer,{1,1000}], Random[Integer,100]}, {10000}]; data3 = Table[{Random[Integer,{1,1000}], Random[Integer,200]}, {10000}]; Timings are on a 1.5 GHz machine running the Mathematica 4.2 kernel In[107]:= Timing[m0 = toAdjacency0[data1];] Out[107]= {5.44 Second, Null} In[108]:= Timing[m1 = toAdjacency1[data1];] Out[108]= {10.5 Second, Null} In[109]:= Timing[m2 = toAdjacency2[data1];] Out[109]= {16.24 Second, Null} In[110]:= m0 === m1 === m2 Out[110]= True Note that for this example the result is not terrible sparse (less than 20%). In[112]:= Count[Flatten[m0], 0] Out[112]= 191374 In[115]:= Timing[m0 = toAdjacency0[data2];] Out[115]= {11.51 Second, Null} In[116]:= Timing[m1 = toAdjacency1[data2];] Out[116]= {10.92 Second, Null} In[117]:= Timing[m2 = toAdjacency2[data2];] Out[117]= {9.07 Second, Null} Curiously this was the first example I tried, and all three methods perform about the same in this case. The result, not suprisingly, is more sparse (40%) because we have the same number of actors and pairs as previously, but now with more events to spread out over the pairs. In[118]:= Count[Flatten[m0], 0] Out[118]= 403232 When we get sparser still, the third method begins to dominate and the first is relatively slower. In[119]:= Timing[m0 = toAdjacency0[data3];] Out[119]= {22.73 Second, Null} In[120]:= Timing[m1 = toAdjacency1[data3];] Out[120]= {10.88 Second, Null} In[121]:= Timing[m2 = toAdjacency2[data3];] Out[121]= {4.96 Second, Null} Now sparsity is over 60%. In[122]:= Count[Flatten[m0], 0] Out[122]= 624350 The relative speed of this last method, in this instance, is derived from the fact that individual event lists are on average half the size of the previous case. Hence the main loop is expected to improve on average by a factor of 2 (you get a factor of 4 for iterating over all pairs in each event, but lose a factor of 2 because there are twice as many event lists). My guess is that a preprocessor that assesses number of actors vs. number of events would be the best way to choose between the first and third methods (which, inexplicably, are labelled as methods 0 and 2). It is not clear to me whether the middle approach will ever dominate. I have not given much thought to concocting examples where it would because offhand I suspect they would be pathological as in dense and with large intersections. As a last remark I'll note that these might run significantly faster if coded with Compile. Whether that is viable depends on the form of the data. In the above example where everything is a machine integer that approach would certainly work. Daniel Lichtblau Wolfram Research ==== First thanks to all, and in particular Bobby Treat, for your help with this question. The best solution was as follows: lst = ReadList[c:data.txt, {Number, Number}] adjacenceMatrix[ x:{{_, _}..}] := Module[{actors, events}, {actors, events} = Union /@ Transpose[x]; Array[If[MemberQ[x, {actors[[#1]], events[[#2]]}], 1, 0] & , {Length[actors], Length[events]}]] a = adjacenceMatrix[lst]; b = a . Transpose[a]; c = b (1 - IdentityMatrix[Length[b]]) C is the desired symmetric matrix with off diagonal values of >=0, indicating the number of times two actors participate in the same event. The diagonal is set to 0. A few items in response to Bobby's message, below. While c is, in fact, a huge matrix with lots of cells equal to zero, that is exactly how we need it structured for our analysis and research question (not relevant to the list, but I'd be happy to discuss off list). Processing time is actually not too bad!! I'm running a PIII 900 with 512 SDRAM, and the code ran a 177 x 3669 matrix in under 90 seconds. MatrixForm [c] presented no problems in viewing in the front end, but then it's only 177 x 177. Tom ********************************************** Thomas P. Moliterno Graduate School of Management University of California, Irvine tmoliter@uci.edu ********************************************** -----Original Message----- columns will be numbered from 1 to the number of observed actors or events, and will correspond to actors and events in sorted order. That said, you're asking for a VERY large matrix, and most of its entries will be zero. I'll suggest another way, later. The following indicates AT MOST 13.4% of the entries could be non-zero: lst = ReadList[moliterno-test1996.txt, {Number, Number}]; {actors, events} = Union /@ Transpose[lst]; N[Length[lst]/(Length[actors]*Length[actors])] 0.13350994338800987 However, a random sample shows that less than 1% will be non-zero: Timing[ Count[(MemberQ[lst, {actors[[Random[Integer, Length[actors]]]], events[[Random[Integer, Length[events]]]]}] & ) /@ Range[10000], True]/ 10000.] {7.515999999999998*Second, 0.008} Nevertheless, the following code should build the matrices you want. I'm using a 2.2GHz P4 and 1024MB RDRAM, so if you have a slower machine, be warned. adjacenceMatrix[ x:{{_, _}..}] := Module[{actors, events}, {actors, events} = Union /@ Transpose[x]; Array[If[MemberQ[x, {actors[[#1]], events[[#2]]}], 1, 0] & , {Length[actors], Length[events]}]] Timing[a = adjacenceMatrix[lst]; ] Dimensions[a] {5.671999999999997*Second, Null} {166, 1778} Timing[b = a . Transpose[a]; ] {0.5309999999999988*Second, Null} You don't want to display a or b in MatrixForm. It will crash your anything at all from the result, and use something like b[[Range[20],Range[4]]]//MatrixForm {{47, 0, 0, 0}, {0, 3, 0, 0}, {0, 0, 7, 1}, {0, 0, 1, 59}, {0, 0, 0, 3}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 1}, {0, 0, 0, 0}, {0, 0, 0, 1}, {0, 0, 0, 0}, {0, 0, 0, 0}, {2, 0, 0, 1}, {0, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 0, 1}, {0, 0, 0, 2}, {0, 0, 0, 0}, {0, 0, 0, 0}} to get a glimpse at some of it. It's the 'a' matrix that's terribly sparse -- the 'b' matrix isn't unreasonable. Elements of the 'a' matrix can be quickly computed by the function aFunction = If[MemberQ[lst, {actors[[#1]], events[[#2]]}], 1, 0] &; That stores a line of code rather than all those ones and zeroes. The b matrix (call it bb this time) can be computed as: Timing[bb = (#1 . Transpose[#1] & ) [Array[aFunction, {Length[actors], Length[events]}]]; ] bb == b {6.1569999999999965*Second, Null} True Bobby Treat -----Original Message----- posting a this was the most helpful solution message to the list, but first I hoped to ask you a follow up question, if I may (and I'll capture your off-line response here in my final posting to the list). I've run the code (copied from you) below, and get the correct output for made-up data, but when I import in real data, I get an error message. Here's the input I'm running: lst = ReadList[c:test1996.txt, {Number, Number}] AdjacenceMatrix[lst : {{_, _} ..}] := Module[{actors, events, adj}, {actors, events} = Union /@ Transpose[lst]; adj = Table[0, {Length[actors]}, {Length[events]}]; Scan[(Part[adj, Sequence @@ #] = 1) &, lst /. MapIndexed[Rule[#1, First[#2]] &, events]]; adj] MatrixForm[a = AdjacenceMatrix[lst]] MatrixForm[b = a.Transpose[a]] And here's what I get for output: Set::partw : Part 300007 of <<1>> does not exist. Set::partw : Part 300007 of <<1>> does not exist. Set::partw : Part 300007 of <<1>> does not exist. General::stop : Further output of Set::partw will be suppressed during this calculation. Then I get the two matrices (a & b as per your code), but they are just filled with zeros. So it gets to about the 4th line of your code, but then doesn't fill-in from my data. Finally, I should note that 30007 is one of the actors in the data that I've read in. In case you want to run this yourself, I've attached the raw data file. There are 166 actors and 1778 events: both actors and events are coded with 6-digit numbers, actors begin with 3's, events with 2's. I'm sure this is a silly question, and that there is an easy answer ... But I sure can't find it. So I really appreciate your help and interest!!!! Tom ********************************************** Thomas P. Moliterno Graduate School of Management University of California, Irvine tmoliter@uci.edu ********************************************** -----Original Message----- If you multiply it by its transpose, you get something else that's useful: lst = {{1, A}, {1, B}, {2, B}, {3, C}, {3, D}, {1, D}, {1, C}}; AdjacenceMatrix[lst : {{_, _} ..}] := Module[{actors, events, adj}, {actors, events} = Union /@ Transpose[lst]; adj = Table[0, {Length[actors]}, {Length[events]}]; Scan[(Part[adj, Sequence @@ #] = 1) &, lst /. MapIndexed[Rule[#1, First[#2]] &, events]]; adj] MatrixForm[a = AdjacenceMatrix[lst]] MatrixForm[b = a.Transpose[a]] Matrix 'b' records how many events two actors have in common. On the diagonal, it shows the total number of events each actor is connected to. It's easy to put zeroes on the diagonal: MatrixForm[c = b (1 - IdentityMatrix[Length[b]])] To get the originally intended incidence matrix, this works: d = c /. {_?Positive -> 1} However, I think matrices 'a' and 'b' are actually more useful, and 'a' easily leads to all the others. Bobby -----Original Message----- AdjacenceMatrix[lst : {{_, _} ..}] := Module[ {actors,events adj}, {events, actors} = Union /@ Transpose[lst]; adj = Table[0, {Length[events]}, {Length[actors]}]; Scan[(Part[adj, Sequence @@ #] = 1) &, lst /. MapIndexed[Rule[#1, First[#2]] &, actors]]; adj ] you get In[]:=AdjacenceMatrix[lst] Out[]={{1, 1, 0, 1}, {0, 1, 0, 0}, {0, 0, 1, 1}} Jens I need to create an adjacency matrix from my data, which is currently in > the form of a .txt file and is basically a two column incidence list. > For example: 1 A > 1 B > 2 B > 3 C > . . > . . > . . > m n Where 1 to m represent actors and A to n represent events. My goal is to > have an (m x m) matrix where cell i,j equals 1 if two actors are > incident to the same event (in the sample above, 1 and 2 are both > incident to B) and 0 otherwise (w/ zeros on the diagonal). I'm new to Mathmatica, and so I'm on the steep part of the learning > curve ... All I've been able to figure out so far is how to get my > incidence list into the program using Import[filename.txt]. But then > what? How do I convert to the adjacency matrix? I've found the > ToAdjacencyMatrix[] command in DiscreteMath`Combinatorica`, but I can't > seem to get it to work ... > Tom ********************************************** > Thomas P. Moliterno > Graduate School of Management > University of California, Irvine > tmoliter@uci.edu > ********************************************** ==== These are working for me. If anybody wants to try this modified keymapping http://66.92.149.152/proprietary/com/wri/proprietary/com/wri/ch05.html http://public.globalsymmetry.com/proprietary/com/wri/KeyEventTranslations.tr .txt STH ==== > These are working for me. If anybody wants to try this modified > keymapping http://66.92.149.152/proprietary/com/wri/proprietary/com/wri/ch05.html > http://public.globalsymmetry.com/proprietary/com/wri/KeyEventTranslations.tr .txt STH I found a bug in my hack of the KeyEventTranslations.tr file which didn't manifest itself in 4.1, but did in 4.2. I had a trailing ',' which was causing Mathematica to hang on startup after the chched KeyEventTranslations.m was created (second launch with the buggy file.) I also discovered that the file I was trying to share had been chmod'ed to 400. I am not sure if that is a daemon running, or scp which did it. It's open now, and I'll keep an eye on it. I'm attaching it as well, just in case. I put it here on my box: ~/.Mathematica/SystemFiles/FrontEnd/TextResources STH @@resource KeyEventTranslations (* Modifiers can be Shift, Control, Command, Option For Macintosh: Command = Command Key, Option = Option Key For X11: Command = Mod1, Option = Mod2 For Windows: Command = Alt, Option = Alt NOTE: I Hacked this for my purposes. I find it more natural. There may be problems. It comes with all the warranty that GNU software does. *) EventTranslations[{ (* Evaluation *) Item[KeyEvent[Enter], EvaluateCells], Item[KeyEvent[KeypadEnter], EvaluateCells], Item[KeyEvent[Return, Modifiers -> {Shift}], EvaluateCells], Item[KeyEvent[KP_Enter], EvaluateCells], Item[KeyEvent[KeypadEnter, Modifiers -> {Shift}], EvaluateNextCell], Item[KeyEvent[KP_Enter, Modifiers -> {Shift}], EvaluateNextCell], Item[KeyEvent[Enter, Modifiers -> {Shift}], EvaluateNextCell], Item[KeyEvent[Return, Modifiers -> {Command}], Evaluate[All]], Item[KeyEvent[Return, Modifiers -> {Option}], SimilarCellBelow], Item[KeyEvent[Escape], ShortNameDelimiter], (* Cursor control *) Item[KeyEvent[Up], MovePreviousLine], Item[KeyEvent[Down], MoveNextLine], Item[KeyEvent[Left], MovePrevious], Item[KeyEvent[Right], MoveNext], Item[KeyEvent[Up, Modifiers -> {Option}], MovePreviousLine], Item[KeyEvent[Down, Modifiers -> {Option}], MoveNextLine], Item[KeyEvent[Right, Modifiers -> {Option}], MoveNextWord], Item[KeyEvent[Left, Modifiers -> {Option}], MovePreviousWord], Item[KeyEvent[Right, Modifiers->{Control}], MoveNextWord], Item[KeyEvent[Left, Modifiers->{Control}], MovePreviousWord], Item[KeyEvent[End], MoveLineEnd], Item[KeyEvent[Home], MoveLineBeginning], (* Selection *) Item[KeyEvent[Right, Modifiers -> {Shift}], SelectNext], Item[KeyEvent[Left, Modifiers -> {Shift}], SelectPrevious], Item[KeyEvent[Right, Modifiers -> {Control, Shift}], SelectNextWord], Item[KeyEvent[Left, Modifiers -> {Control, Shift}], SelectPreviousWord], Item[KeyEvent[Down, Modifiers -> {Shift}], SelectNextLine], Item[KeyEvent[Up, Modifiers -> {Shift}], SelectPreviousLine], Item[KeyEvent[Home, Modifiers -> {Shift}], SelectLineBeginning], Item[KeyEvent[End, Modifiers -> {Shift}], SelectLineEnd], Item[KeyEvent[., Modifiers -> {Control}], ExpandSelection], (* Notebook window control *) Item[KeyEvent[PageUp], ScrollPageUp], Item[KeyEvent[PageDown], ScrollPageDown], Item[KeyEvent[Prior], ScrollPageUp], Item[KeyEvent[Next], ScrollPageDown], Item[KeyEvent[Home, Modifiers -> {Control}], ScrollNotebookStart], Item[KeyEvent[End, Modifiers -> {Control}], ScrollNotebookEnd], (* Input *) Item[KeyEvent[Return], Linebreak], Item[KeyEvent[Tab], Tab], Item[KeyEvent[i, Modifiers -> {Control}], Tab], Item[KeyEvent[Backspace], DeletePrevious], Item[KeyEvent[Delete], DeleteNext], Item[KeyEvent[ForwardDelete], DeleteNext], (* Typesetting input *) Item[KeyEvent[6, Modifiers -> {Control}], Superscript], Item[KeyEvent[Keypad6, Modifiers -> {Control}], Superscript], Item[KeyEvent[^, Modifiers -> {Control}], Superscript], Item[KeyEvent[-, Modifiers -> {Control}], Subscript], Item[KeyEvent[_, Modifiers ->{Control}], Subscript], Item[KeyEvent[/, Modifiers -> {Control}], Fraction], Item[KeyEvent[KP_Divide, Modifiers -> {Control}], Fraction], Item[KeyEvent[2, Modifiers -> {Control}], Radical], Item[KeyEvent[Keypad2, Modifiers -> {Control}], Radical], Item[KeyEvent[@, Modifiers -> {Control}], Radical], Item[KeyEvent[7, Modifiers -> {Control}], Above], Item[KeyEvent[&, Modifiers -> {Control}], Above], Item[KeyEvent[Keypad7, Modifiers -> {Control}], Above], Item[KeyEvent[=, Modifiers -> {Control}], Below], Item[KeyEvent[+, Modifiers -> {Control}], Below], Item[KeyEvent[,, Modifiers -> {Control}], NewColumn], Item[KeyEvent[Return, Modifiers -> {Control}], NewRow], Item[KeyEvent[9, Modifiers -> {Control}], CreateInlineCell], Item[KeyEvent[(, Modifiers -> {Control}], CreateInlineCell], Item[KeyEvent[Keypad9, Modifiers -> {Control}], CreateInlineCell], Item[KeyEvent[), Modifiers -> {Control}], MoveNextCell], Item[KeyEvent[0, Modifiers -> {Control}], MoveNextCell], Item[KeyEvent[Keypad0, Modifiers -> {Control}], MoveNextCell], Item[KeyEvent[Left, Modifiers -> {Control}, CellClass -> BoxFormData], NudgeLeft], Item[KeyEvent[Right, Modifiers -> {Control}, CellClass -> BoxFormData], NudgeRight], Item[KeyEvent[Down, Modifiers -> {Control}, CellClass -> BoxFormData], NudgeDown], Item[KeyEvent[Up, Modifiers -> {Control}, CellClass -> BoxFormData], NudgeUp], Item[KeyEvent[8, Modifiers -> {Control}], InsertRawExpression], Item[KeyEvent[*, Modifiers -> {Control}], InsertRawExpression], Item[KeyEvent[Keypad8, Modifiers -> {Control}], InsertRawExpression], Item[KeyEvent[5, Modifiers -> {Control}, CellClass -> BoxFormData], Otherscript], Item[KeyEvent[Keypad5, Modifiers -> {Control}, CellClass -> BoxFormData], Otherscript], Item[KeyEvent[%, Modifiers -> {Control}, CellClass -> BoxFormData], Otherscript], (* Typesetting motion commands *) Item[KeyEvent[ , Modifiers -> {Control}], MoveExpressionEnd], Item[KeyEvent[Tab, Modifiers -> {Shift}, CellClass -> BoxFormData], MovePreviousPlaceHolder], Item[KeyEvent[s, Modifiers -> {Command, Control}, CellClass -> BoxFormData], MovePreviousExpression], Item[KeyEvent[S, Modifiers -> {Control, Command, Shift}, CellClass -> BoxFormData], MoveNextExpression], Item[KeyEvent[S, Modifiers -> {Control, Shift}, CellClass -> BoxFormData], DeleteNextExpression], Item[KeyEvent[s, Modifiers -> {Control}, CellClass -> BoxFormData], DeletePreviousExpression], Item[KeyEvent[k, Modifiers -> {Control}], CompleteSelection[True]], (* Miscellaneous menu commands *) Item[KeyEvent[Delete, Modifiers -> {Control}], Cut], Item[KeyEvent[Insert, Modifiers -> {Control}], Copy], Item[KeyEvent[Insert, Modifiers -> {Shift}], Paste[After]], Item[KeyEvent[z, Modifiers -> {Control}], Undo], Item[KeyEvent[c, Modifiers -> {Control}], Copy], Item[KeyEvent[x, Modifiers -> {Control}], Cut], Item[KeyEvent[v, Modifiers -> {Control}], Paste[After]], Item[KeyEvent[F1], SelectionHelpDialog] (* Unsupported features and examples *) (* Item[KeyEvent[v, Modifiers -> {Control}], SelectionSpeakSummary], *) (* Item[KeyEvent[v, Modifiers -> {Control, Shift}], SelectionSpeak] *) }] ==== >particular, the y-axis label is typically rotated by 90deg so that it >reads up the y-axis. This works fine on macs and windoze, but under >linux the label runs up the y-axis; however, the letters are rotated >so that they are the same orientation as that for the x-axis. >Printouts of the NB are fine, but it looks really stupid when using a >video projector to teach or give a talk. I have mentioned this before, >perhaps, but it is also a real problem with Mathematica. I personally >don't care why the label looks peculiar, just that it does and that >there is no easy workaround. ==== >I'm writing to report what I consider to be a bug. First, I want to >show a simplified example of the problem. Consider the following >expression: > >expr=0.22 + x[0] + (3*(-0.16+ x[1]))/4 + (9*(0.546 + x[2]))/16; > >When simplified I expected to get some real number plus >x[0]+3x[1]/4+9x[2]/16, but instead I get the following: > >Simplify[expr] 0.407125 + x[0] + 0.75 x[1] + 0.5625 x[2] > >As you can see, for some reason Mathematica converted the fractions >3/4 and 9/16 to real machine numbers. I consider this to be a bug. You really are not seeing a loss of precision here. When simplify carries out the indicated multiplication such as 9*.546/16 a machine precision number is returned because on of the arguments only has machine precision. It would be incorrect for Mathematica to return a result with greater precision than the arguements. It would also be incorrect for Mathematica to refuse to preform the required multiplications when simplifying this expression. Or said differently, if you want an exact result from Mathematica *all* of the information you supply Mathematica must also be exact. It is not sensible for Mathematica to do otherwise. ==== There is nothing imprecise about a floating point number. Mathematica's non-standard usage is to treat some numbers as intervals. This non-standard usage comes from the attitude that everything I need to know about numerical computations I learned in Freshman physics lab. Anyway, I'm just pointing this out so that you realize that you are not talking about truth and beauty, but about decisions made in the Mathematica design. For example, 0.25 in IEEE floating point format is representing the EXACT value 1/4. The rational number 1/3 does not have an exact corresponding binary floating point number. That does not prevent one from computing the closest number, which from that point on that (other) number is EXACTLY represented. An analysis of your arithmetic or simplification in which each floating point number aaaa*2^bb is changed to that exact rational number may give you more satisfactory answers that an interval-like computation in which all data is submerged in mush. RJF >>It seems to me that you are arguing that if you have an expression >>consisting of one term which is very inprecise and another term which >>is very precise or exact, then the total expression is only as precise >>as the least precise portion of the expression. >> Yes. >>This is total nonsense. >> Not exactly. >>Consider adding the following terms: >> >1.234567890123456`16 + 0.00000000000000001`1 >> >consisting of one term with precision 16 and another term with >>precision 1. By your argument, Mathematica should return an answer >>with only a single digit of precision. Of course, Mathematica does no >>such thing. >> I had not considered adding two terms with much different magnitude and much different precision. Consider a different example i.e., 1.234567890123456`16 + 0.1`1 Mathematica does not and should not return a result with 16 digits of precision ==== Bill, See my comments below. > > There is no logical reason to insist part of the expression to be exact when another part is inexact. You cannot gain more precision than the least precise portion of the expression. Further, there is extra processing overhead associated with maintaining exact epressions as well as additional storage requirements. For a simple expression such as your example the additional overhead is insignificant. But it increases for every exact term in the expression. It doesn't take all that many terms until the overhead associate with exact computation becomes noticeable. > It seems to me that you are arguing that if you have an expression consisting of one term which is very inprecise and another term which is very precise or exact, then the total expression is only as precise as the least precise portion of the expression. This is total nonsense. Consider adding the following terms: 1.234567890123456`16 + 0.00000000000000001`1 consisting of one term with precision 16 and another term with precision 1. By your argument, Mathematica should return an answer with only a single digit of precision. Of course, Mathematica does no such thing. >Even more troubling (to me, at least) is the >following: > >x[0]+3x[1]/4+9x[2]/16+.4//Simplify > >0.4 + x[0] + 0.75 x[1] + 0.5625 x[2] > >I don't want Simplify to change my nice rational numbers to machine >number approximations. > > If you want exact answers you *must* have *all* terms in the expresssion exact. Simply put either an expression is exact or not. No expression can be exact unless *all* of the terms within it are exact. When did I ever say that I wanted exact answers? In the example above, I wanted Simplify to do nothing, that is, leave the expression as a sum of an inexact quantity with some exact quantities. In the work where this situation arose, the inexact quantities are typically very small and the exact quantities are large, so that the precision of the overall expression when extended precision numbers are substituted for the x[i] is typically the same as the precision of the numbers being substituted. For example, suppose x[0] and x[2] are zero, and x[1] is 1`25 10^25. Substituting these numbers into the original expression will yield a result with a precision of 25, whereas substituting these numbers into the simplified expression will only have a precision of 16. I've worked very hard to keep the precision of my numbers as high as possible, and I don't want Mathematica to arbitrarily turn those very high precision numbers into much lower precision numbers. Carl Woll Physics Dept U of Washington ==== Bill, Let's step through the expansion here. 9*(0.546+x[2]))/16 can be expanded to 9*0.546/16 + 9*x[2]/16 which becomes .307125 + 9*x[2]/16 My question was why the 9/16 gets converted to .5625, as I see no reason to do so. Even more troubling (to me, at least) is the following: x[0]+3x[1]/4+9x[2]/16+.4//Simplify 0.4 + x[0] + 0.75 x[1] + 0.5625 x[2] I don't want Simplify to change my nice rational numbers to machine number approximations. Carl Woll Physics Dept U of Washington > >I'm writing to report what I consider to be a bug. First, I want to >show a simplified example of the problem. Consider the following >expression: > >expr=0.22 + x[0] + (3*(-0.16+ x[1]))/4 + (9*(0.546 + x[2]))/16; > >When simplified I expected to get some real number plus >x[0]+3x[1]/4+9x[2]/16, but instead I get the following: > >Simplify[expr] 0.407125 + x[0] + 0.75 x[1] + 0.5625 x[2] > >As you can see, for some reason Mathematica converted the fractions >3/4 and 9/16 to real machine numbers. I consider this to be a bug. > > You really are not seeing a loss of precision here. When simplify carries out the indicated multiplication such as 9*.546/16 a machine precision number is returned because on of the arguments only has machine precision. It would be incorrect for Mathematica to return a result with greater precision than the arguements. It would also be incorrect for Mathematica to refuse to preform the required multiplications when simplifying this expression. > > Or said differently, if you want an exact result from Mathematica *all* of the information you supply Mathematica must also be exact. It is not sensible for Mathematica to do otherwise. > ==== No, Euler proved that series divergent in 1737. It's the usual theorem used to show that while the primes are sparse, they're not as sparse as the squares (as the sum of THEIR inverses converges). Bobby -----Original Message----- Sal. Oppenheim jr. & Cie. KGaA Koenigsberger Strasse 29 D-60487 Frankfurt am Main GERMANY Mobile: +49(0)172 6 74 95 77 Internet: http://www.oppenheim.de ==== Timing[Sum[1./Prime[n], {n, 1000000}]] {13.860000000000001*Second, 3.0682190480544405} Bobby -----Original Message----- Sal. Oppenheim jr. & Cie. KGaA Koenigsberger Strasse 29 D-60487 Frankfurt am Main GERMANY Mobile: +49(0)172 6 74 95 77 Internet: http://www.oppenheim.de ==== That makes about twenty posts this week detailing nothing but problems the FrontEnd). I had been really considering it. Bobby -----Original Message----- resulted in a set of animation control buttons appearing in the bottom frame of the window. I clicked on one of these buttons, but nothing happened. I looke back in the menu and saw M-y as a keyboard shorcut to run an animation. I tried that with no result. I clicked another button in graphics control set, and my X windows locked up. This included the keyboard's ability to give me another display by using Ctl+Alt+F1. I went to another system and ssh-ed in and found Mathematica had over 50% of my user resources, and was climbing. The same was true for VM. I have a gig of physical RAM. Once I killed Mathematica, my X came back to life. I've had several bad experiences with Mathematica and X. I honestly believe there help isolate and fix these. Have others had such problems? STH ==== > That makes about twenty posts this week detailing nothing but problems > the FrontEnd). I had been really considering it. Bobby > A few other points on this topic, if I may. I've found solutions to a lot of the problems I was having, and documented them. For example, I have the keyboard working the way I want it. C-x, C-v, C-c, C-z, all do what I expect them to, as does Delete. I used to have X restarts after extended periods of running Mathematica. That I haven't had recently. I may simply have thrashed X when I clicked too many buttons in sequence. I just wanted to report that it happened. The same thing might happen on XP. I've had my problems there as well. Not with Mathematica, but with other programs. I haven't even attempted Mathematica on XP. I'm sure it is a bit smoother to use. I guess I was just a bit upset at the sense that WRI are still stuck in the just completing my download of KDE 3.1 Beta 2. Things have changed. Gotta go install a few rpms and restart X. Bye, STH ==== > That makes about twenty posts this week detailing nothing but problems > the FrontEnd). I had been really considering it. Bobby Please keep in mind that this was on Mathematica 4.1, I'll have 4.2 tomorrow, and we'll see how that goes. This isn't really the result I had hoped for by I very much wish WRI would give us a dual boot license. That way, we can use Mathematica in either environment the current situation dictates as the best. with Windows. I just don't do that as a matter of course. I've been related issuse, either because they aren't sure if the problem is their that second reason one bit. Hey, if it locks up my X, I want to know if that happens to others, and I want to identify the source of the problem. What I really would like to gain from all my negative statements is solutions to what I perceive as problems. If not that, then perhaps the perspective which makes me understand that what I see as problems are really just my unfamiliarity with the product. I also want to get others platform. That's how open source works. All that being said, if you are in a situation where an X lockup would really do harm to your project, I would say that I cannot claim it won't happen to you. OTOH, I am able to break just about any system. I can't swear to you that Mathematica won't lock up your Windows system. I can say you will not have as easy a time shelling into it and trying to recover your system without rebooting. STH Reply-To: jmt@dxdydz.net ==== Sorry, I thought I had seen a demonstration, some years ago ! > This sum converges, see a math text book ! > Dear Colleagues, I calculated: Sum[1/Prime[n], {n, 15000}] // N Result: 2.74716 Now I wonder if this sum will converge or keep on growing, albeit very > slowly. > Matthias Bode > Sal. Oppenheim jr. & Cie. KGaA > Koenigsberger Strasse 29 > D-60487 Frankfurt am Main > GERMANY > Mobile: +49(0)172 6 74 95 77 > Internet: http://www.oppenheim.de > Reply-To: murray@math.umass.edu ==== It is well known that the infinite series of reciprocals of the primes DIVERGES! See, for example: http://www.utm.edu/research/primes/infinity.shtml > Dear Colleagues, I calculated: Sum[1/Prime[n], {n, 15000}] // N Result: 2.74716 Now I wonder if this sum will converge or keep on growing, albeit very > slowly. > Matthias Bode > Sal. Oppenheim jr. & Cie. KGaA > Koenigsberger Strasse 29 > D-60487 Frankfurt am Main > GERMANY > Mobile: +49(0)172 6 74 95 77 > Internet: http://www.oppenheim.de -- Murray Eisenberg murray@math.umass.edu Mathematics & Statistics Dept. Lederle Graduate Research Tower phone 413 549-1020 (H) University of Massachusetts 413 545-2859 (W) 710 North Pleasant Street Amherst, MA 01375 Reply-To: jmt@dxdydz.net ==== This sum converges, see a math text book ! > Dear Colleagues, I calculated: Sum[1/Prime[n], {n, 15000}] // N Result: 2.74716 Now I wonder if this sum will converge or keep on growing, albeit very > slowly. > Matthias Bode > Sal. Oppenheim jr. & Cie. KGaA > Koenigsberger Strasse 29 > D-60487 Frankfurt am Main > GERMANY > Mobile: +49(0)172 6 74 95 77 > Internet: http://www.oppenheim.de > ==== The fact that Sum[1/Prime[n], {n, 1,Infinity}]==Infinity is a rather famous theorem of Euler. It implies that there must be infinitely many primes (otherwise the sum would be finite), and was the beginning of a vast area of mathematics, which includes such concepts as Dirichlet series, Riemann's zeta function etc. Andrzej Kozlowski Yokohama, Japan http://www.mimuw.edu.pl/~akoz/ http://platon.c.u-tokyo.ac.jp/andrzej/ On Wednesday, October 2, 2002, at 04:31 PM, Matthias.Bode@oppenheim.de > Dear Colleagues, > > I calculated: > > Sum[1/Prime[n], {n, 15000}] // N > > Result: 2.74716 > > Now I wonder if this sum will converge or keep on growing, albeit very > slowly. > > > Matthias Bode > Sal. Oppenheim jr. & Cie. KGaA > Koenigsberger Strasse 29 > D-60487 Frankfurt am Main > GERMANY > Mobile: +49(0)172 6 74 95 77 > Internet: http://www.oppenheim.de > > > > ==== Here's a start. If you want the thing to be greater than zero, set it equal to z (which we'll assume is greater than zero) and solve for Log[x]: Log[x, a] + Log[a*x, a] == z /. Log[a_*b_] -> Log[a] + Log[b] {f, g} = Log[x] /. Simplify[Solve[%, Log[x]]] Log[a]/Log[x] + Log[a]/(Log[a] + Log[x]) == z {-(((-2 + z + Sqrt[4 + z^2])*Log[a])/(2*z)), ((2 - z + Sqrt[4 + z^2])* Log[a])/(2*z)} Neither solution appears to be extraneous. Now the task is to find the range of these functions over positive z. Take a look at their derivatives: D[f, z] // Simplify D[g, z] // Simplify ((-1 + 2/Sqrt[4 + z^2])* Log[a])/z^2 ((-1 - 2/Sqrt[4 + z^2])*Log[a])/z^2 A little study shows that f' and g' have their signs opposite to Log[a]. Both functions are monotone. The following limits: Outer[Limit[#1, z -> #2] &, {f, g}, {0, Infinity}] Exp@% {{-(Log[a]/2), -Log[a]}, {Infinity*Log[a], 0}} {{1/Sqrt[a], 1/a}, {Indeterminate, 1}} show that f varies from -Log[a]/2 to -Log[a] and g varies from 0 to Infinity if Log[a]>0 and 0 to -Infinity if Log[a]<0. Exponentiation gives ranges for x: -1/Sqrt[a] to 1/a for f, for instance. But what does all this mean? When a>1, either x>1 or 1/a < x < 1/Sqrt[a]. When a<1, either 0, Moderator Reply-To: ==== Try this: To the original function, add a function that's (a) zero when the imaginary part is larger than some epsilon value you choose, (b) fairly large when the imaginary part is 0 or negative, and (c) as smooth as possible. For instance, something like: f=Max[(1 - x/epsilon)^5, 0] This function has four continuous derivatives in the real components -- though not in the complex variable! If it doesn't penalize the real root enough, multiply f by a constant bigger than 1 and try again. Bobby Treat -----Original Message----- are interested, the zeros are the roots of the dispersion relation for a plasma interacting with a laser). Sometimes FindRoot picks up one of these instead of the one I want. So, I'd like to tell mathematica to look for a root only in a certain rectangular region of the complex plane. Well, if I could tell it, 'look for roots with imag. part > something', I'd be happy too. I tried specifying complex values for the start and stop points of an interval, hoping mathematica would interpret these as the corners of a rectangle. No such luck. Any help would be greatly appreciated. I'd also like to point out that this and other issues about complex roots are not clearly addressed in the built-in help files. ==== This sum converges, see a math text book ! That's nonsense http://mathworld.wolfram.com/PrimeSums.html Jens Dear Colleagues, > > I calculated: > > Sum[1/Prime[n], {n, 15000}] // N > > Result: 2.74716 > > Now I wonder if this sum will converge or keep on growing, albeit very > slowly. > > > Matthias Bode > Sal. Oppenheim jr. & Cie. KGaA > Koenigsberger Strasse 29 > D-60487 Frankfurt am Main > GERMANY > Mobile: +49(0)172 6 74 95 77 > Internet: http://www.oppenheim.de > > > ==== You need to see: http://www.research.att.com/cgi-bin/access.cgi/as/njas/sequences/eisA.cgi?An um=A016088 > >>This sum converges, see a math text book ! >> > >That's nonsense > >http://mathworld.wolfram.com/PrimeSums.html > > Jens > > >> >Dear Colleagues, > >I calculated: > >Sum[1/Prime[n], {n, 15000}] // N > >Result: 2.74716 > >Now I wonder if this sum will converge or keep on growing, albeit very >slowly. > > >Matthias Bode >Sal. Oppenheim jr. & Cie. KGaA >Koenigsberger Strasse 29 >D-60487 Frankfurt am Main >GERMANY >Mobile: +49(0)172 6 74 95 77 >Internet: http://www.oppenheim.de > > > ==== I have updated my package Biokmod. It can be downloaded from: http://web.usal.es/~guillerm/biokmod.htm I developped this package thinking in biokinetic application and internal dosimetry, but it can be also applied for other kind of problems envolving System of ODE with many variables. I will appreciate any coments Guillermo Sanchez http://web.usal.es/~guillerm ==== I use BinaryImport to read a file as follows: BinaryImport[file,{Byte..}] then I use Partition to rebuild the data of dimensions 252 x 253 x 255.... This works but it takes about half an hour to read the file....it's a 16 MByte file.....any way to improve this? thanks....jerry blimbaum Reply-To: kuska@informatik.uni-leipzig.de ==== BinaryImport[] is complet unusable for this task. I tryed the same with similar data sets and run out of kernel memory (with 1.5 GByte RAM) & 3GB swap). The WRI support respondet, that BinaryImport[] is not for reading *large* binary data. You can have the beta version of MathGL3d 3.1 that has an extra C-Function for that task. Since it also include excelent volume rendering functions and a native format for reading and writing compressed volume data files you should use MathGL3d 3.1b. Contact me direct if you wish to beta test the new version. Jens I use BinaryImport to read a file as follows: BinaryImport[file,{Byte..}] then I use Partition to rebuild the data of dimensions 252 x 253 x 255.... This works but it takes about half an hour to read the file....it's a 16 > MByte file.....any way to improve this? thanks....jerry blimbaum ==== Does any one know of a way to produce Phase Plane Diagrams in mathematica? I need to draw a couple of direction field and analyse the stability of critical points for my systems of equations . Ajadi __________________________________________________ Do You Yahoo!? Everything you'll ever need on one web page http://uk.my.yahoo.com Reply-To: kuska@informatik.uni-leipzig.de ==== if you don't like PlotField[] you should try to get a copy of the book Visual DSolve http://store.wolfram.com/view/book/D0706.str and the book package. Jens > Does any one know of a way to produce Phase Plane > Diagrams in mathematica? > I need to draw a couple of direction field and > analyse the stability of critical points for my > systems of equations . > Ajadi __________________________________________________ > Do You Yahoo!? > Everything you'll ever need on one web page > http://uk.my.yahoo.com ==== Please ignore a similar question I just posted about BinaryImport...I forgot an hour to import 16 MByte file, whereas this technique took less then 5 seconds...special thanks to Mariusz... jerry blimbaum NSWC panama city, fl -----Original Message----- Mariusz Jankowski University of Southern Maine mjkcc@usm.maine.edu 207-780-5580 > The question: > What is the fastest way to read binary files in Mathematica 4.0 ? > I think the fastest is with ReadList (indeed ReadSounFile that use it, seems > to be better than BinaryImport), but when i use this command... > data = ReadList[filePath, Byte] > ....it doesn't read whole file; can somebody tell me the reason? > > Raf. > > P.S.: > I made some simple tests (@ 16 bit): > > << Experimental` > data = BinaryImport[fileRawPath, Table[Integer16, {4000}], > ByteOrdering -> -1]; => 10 seconds > > data = ReadListBinary[fileRawPath, SignedInt16, ByteOrder -> > LeastSignificantByteFirst]; = > 26 seconds > > << Miscellaneous`Audio` > data = ReadSoundfile[fileWavPath] => 1.54 seconds > > ==== I came across this, and thought I would share. This may be OBE if the font selection is better in 4.2. I'll that installed by this time tomorrow...I hope. http://cgm.cs.mcgill.ca/~luc/math.html I started reading through this list, and had visions of recursively downloading the entire internet looking for the font's I really need. Anybody know what fonts I should have installed on my SuSE box to satisfy Mathematica's default expectations? STH ==== In: DSolve[y*D[u[x, y],x] == x*D[u[x, y],y], u[x,y], {x, y}] Out: {{u[x, y] -> C[1][(1/2)*(x^2 + y^2)]}} Square brackets are used as grouping symbols in the result!?? :^O Somebody say it isn't so. --- Selwyn Hollis ==== It isn't so. C[1] is an arbitrary (smooth) function. After all, what you have got is a partial differential equation. For example, you can take C[1] to be Sin: In[1]:= v[x_, y_] = u[x, y] /. DSolve[y*D[u[x, y], x] == x*D[u[x, y], y], u[x, y], {x, y}] /. C[1] -> Sin Out[1]= {Sin[(1/2)*(x^2 + y^2)]} In[2]:= y*D[v[x, y], x] == x*D[v[x, y], y] Out[2]= True Andrzej Kozlowski Yokohama, Japan http://www.mimuw.edu.pl/~akoz/ http://platon.c.u-tokyo.ac.jp/andrzej/ > > In: DSolve[y*D[u[x, y],x] == x*D[u[x, y],y], u[x,y], {x, y}] > > Out: {{u[x, y] -> C[1][(1/2)*(x^2 + y^2)]}} > > Square brackets are used as grouping symbols in the result!?? :^O > > Somebody say it isn't so. > > --- > Selwyn Hollis > > > > Reply-To: ==== My OPINION is that extra graphics RAM is useful primarily for 3D games (which are themselves completely useless). A static 3D plot doesn't need that much graphics RAM -- it's the rapid transformation of it, to simulate live action, that may require it. On the other hand, if the manufacturer's limits are that low for graphics RAM, I would get another manufacturer. Who knows what other limitations and compromises they'll saddle you with? I would be very suspicious. Bobby -----Original Message----- Is 32 MB adequate not just now, but likely to be adequate as well for the near future (say, a 3- to 5-year equipment lifetime)? -- Murray Eisenberg murray@math.umass.edu Mathematics & Statistics Dept. Lederle Graduate Research Tower phone 413 549-1020 (H) University of Massachusetts 413 545-2859 (W) 710 North Pleasant Street Amherst, MA 01375 Reply-To: kuska@informatik.uni-leipzig.de ==== My OPINION is that extra graphics RAM is useful primarily for 3D games Or complex 3d scientific visualizations ? Textures ? Try to render the skull from a 256^3 CT scan or the output of a 3d plasma simulation and you will know *what* can be done with extra 3d RAM > (which are themselves completely useless). The major effect is, that 3d Games make 3d graphics hardware less expensive. Five years ago a SGI cost 20-30 000 $ and today you can have more 3d power for 400 $ Jens > A static 3D plot doesn't > need that much graphics RAM -- it's the rapid transformation of it, to > simulate live action, that may require it. On the other hand, if the manufacturer's limits are that low for > graphics RAM, I would get another manufacturer. Who knows what other > limitations and compromises they'll saddle you with? I would be very > suspicious. Bobby -----Original Message----- We are about to order new PCs for a university student lab in which > Mathematica will be installed. Of course they will be using 2D and 3D > graphics -- plots of surfaces, e.g. Sooner or later students will want > to rotate such plots, too. An unresolved issue is how much graphics RAM to get. On existing > machines we typically have 64MB. But for the PCs we are looking at, > manufacturer's limits on graphics RAM, rather than cost, seems to limit > us to 32 MB. Is 32 MB adequate not just now, but likely to be adequate as well for > the near future (say, a 3- to 5-year equipment lifetime)? -- > Murray Eisenberg murray@math.umass.edu > Mathematics & Statistics Dept. > Lederle Graduate Research Tower phone 413 549-1020 (H) > University of Massachusetts 413 545-2859 (W) > 710 North Pleasant Street > Amherst, MA 01375 ==== Greetings MathGroup, My name is Steve Earth, and I am a new subscriber to this list and also a new user of Mathematica; so please forgive this rather simple question... I would like to enter the quartic x^4 + x^3 + x^2 + x + 1 into Mathematica and have it be able to tell me that it factors into (x^2 + GoldenRatio x + 1) ( x^2 - 1/GoldenRatio x + 1) What instructions do I need to execute to achieve this output? -Steve Earth Harker School http://www.harker.org/ ==== Steve The notebook given after NOTEBOOK below contains functions for factoring and partial fractioning. Here is an application to your problem: the first stage avoids our needing to know anything about the answer. fc=FactorR[x^4+x^3+x^2+x+1,x] (1 - (1/2)*(-1 - Sqrt[5])*x + x^2)* (1 - (1/2)*(-1 + Sqrt[5])*x + x^2) Now we need to get rid of Sqrt[5] in terms of GoldenRatio. This is rather messy: Simplify/@(fc/. Sqrt[5][Rule]2 GoldenRatio-1) (1 + x - GoldenRatio*x + x^2)*(1 + GoldenRatio*x + x^2) Simplify/@(%/.-GoldenRatio[Rule] 1/GoldenRatio -1) (1 + x/GoldenRatio + x^2)*(1 + GoldenRatio*x + x^2) Another example PartialFractionsR[(1 + x)x/(1 - 3*x + x^2), x] 1 - (2*(-1 + 4*x))/((3 + Sqrt[5] - 2*x)*(-3 + 2*x)) + (2*(-1 + 4*x))/((-3 + 2*x)*(-3 + Sqrt[5] + 2*x)) Simplify[%] (x*(1 + x))/(1 - 3*x + x^2) NOTEBOOK: to make a notebook from the following, copy from the next line to the line preceding XXX and paste into a new Mathematica notebook. Notebook[{ Cell[CellGroupData[{ Cell[Factors and PartialFractions, Subtitle], Cell[Allan Hayes, 16 August 2001, Text], Cell[< Here are some functions for factoring and expressing in partial fractions over the reals and over the complex numbers. >, Text], Cell[BoxData[ (Quit)], Input], Cell[BoxData[{ (Off[General::spell1, General::spell]), n, ((FactorC::usage = ;)n), n, ((FactorR::usage = ;)n), n, ((PartialFractionsC::usage = ;)n), n, ((PartialFractionsR::usage = ;)), n, (On[General::spell1, General::spell])}], Input, InitializationCell->True], Cell[TextData[{ FactorC[p_, x_] := , StyleBox[(*over complex numbers*), FontFamily->Arial, FontWeight->Plain], nTimes @@ Cases[Roots[p == 0, x, n Cubics -> False], u_ == v_ -> x - v]n nFactorR[p_, x_] := , StyleBox[(*over reals, coefficients must be real*), FontFamily->Arial, FontWeight->Plain], n (Times @@ Join[Cases[#1, u_ == v_ /; Im[v] == 0 :> n x - v], Cases[#1, u_ == v_ /; Im[v] > 0 :> n x^2 - x*2*Re[v] + Abs[v]^2]] & )[n Roots[p == 0, x, Cubics -> False]] }], Input, InitializationCell->True], Cell[TextData[{ PartialFractionsC[p_, x_] := , StyleBox[(*over complex numbers*), FontFamily->Arial, FontWeight->Plain], n(#+Apart[#2/FactorC[#3,x]])&@@Flatten[{PolynomialReduce[#,#2], #2}]&[Numerator[#],Denominator[#]]&[Together[p]]n n PartialFractionsR[p_, x_] := , StyleBox[(*over reals, coefficients must be real*), FontFamily->Arial, FontWeight->Plain], n(#+Apart[#2/FactorR[#3,x]])&@@Flatten[{PolynomialReduce[#,#2], #2}]&[Numerator[#],Denominator[#]]&[Together[p]] }], Input, InitializationCell->True], Cell[CellGroupData[{ Cell[PROGRAMMING NOTES, Subsubsection], Cell[TextData[{ The option , StyleBox[Cubics->False, FontFamily->Courier], is used to keep the roots of cubics in , StyleBox[Root[....], FontFamily->Courier], form. This is better for computation.n, StyleBox[Re[v], FontFamily->Courier], and , StyleBox[Abs[v]^2, FontFamily->Courier], are used rather than , StyleBox[v+Conjugate[v] , FontFamily->Courier], and , StyleBox[v*Conjugate[v], FontFamily->Courier], to prevent , StyleBox[Apart, FontFamily->Courier], from factorising , StyleBox[x^2 - x*2*Re[v] + Abs[v]^2], FontFamily->Courier], back to complex form. }], Text] }, Closed]], Cell[CellGroupData[{ Cell[EXAMPLES, Subsubsection], Cell[pol = Expand[(x - 1)*(x + 1)^2*(x^2 + x + 1)^2*(x^2 + 4)]; , Input], Cell[CellGroupData[{ Cell[f1 = FactorC[pol, x], Input], Cell[BoxData[ ((((-1) + x)) (((-2) [ImaginaryI] + x)) ((2 [ImaginaryI] + x)) ((1 + x))^2 (((((-1)))^(1/3) + x))^2 (((-(((-1)))^(2/3)) + x))^2)], Output] }, Open ]], Cell[CellGroupData[{ Cell[f2 = FactorR[pol, x], Input], Cell[BoxData[ ((((-1) + x)) ((1 + x))^2 ((4 + x^2)) ((1 + x + x^2))^2)], Output] }, Open ]], Cell[CellGroupData[{ Cell[f3 = FactorR[x^3 + x + 1, x], Input], Cell[BoxData[ (((x - Root[1 + #1 + #1^3 &, 1])) ((x^2 - 2 x Root[(-1) + 2 #1 + 8 #1^3 &, 1] + Root[(-1) - #1^4 + #1^6 &, 2]^2)))], Output] }, Open ]], Cell[< Root objects appear because of the option Cubics->False in Roots. We can sometimes get radical forms, but notice the complication. >, Text], Cell[CellGroupData[{ Cell[ToRadicals[f3], Input], Cell[BoxData[ (((((2/(3 (((-9) + @93)))))^(1/3) - ((1/2 (((-9) + @93))))^(1/3)/3^(2/3) + x)) ((1/3 + 1/3 ((29/2 - (3 @93)/2))^(1/3) + 1/3 ((1/2 ((29 + 3 @93))))^(1/3) - 2 ((((1/2 ((9 + @93))))^(1/3)/(2 3^(2/3)) - 1/(2^(2/3) ((3 ((9 + @93))))^(1/3)))) x + x^2)))], Output] }, Open ]], Cell[Inexact forms can be found, from f3 :, Text], Cell[CellGroupData[{ Cell[N[f3], Input], Cell[BoxData[ (((((0.6823278038280193`)([InvisibleSpace])) + x)) ((((1.4655712318767682`)([InvisibleSpace])) - 0.6823278038280193` x + x^2)))], Output] }, Open ]], Cell[or directly, Text], Cell[CellGroupData[{ Cell[f3 = FactorR[x^3 + x + 1//N, x], Input], Cell[BoxData[ (((((0.6823278038280193`)([InvisibleSpace])) + x)) ((((1.4655712318767682`)([InvisibleSpace])) - 0.6823278038280193` x + x^2)))], Output] }, Open ]], Cell[Partial fractions, Text], Cell[CellGroupData[{ Cell[pf1 = PartialFractionsR[(2 + x)/pol, x], Input], Cell[BoxData[ (1/(60 (((-1) + x))) - 1/(10 ((1 + x))^2) - 39/(100 ((1 + x))) + ((-54) - 31 x)/(4225 ((4 + x^2))) + ((-1) + 3 x)/(13 ((1 + x + x^2))^2) + (44 + 193 x)/(507 ((1 + x + x^2))))], Output] }, Open ]], Cell[CellGroupData[{ Cell[pf2 = PartialFractionsR[(1 + x)x/(1 - 3*x + x^2), x], Input], Cell[< 1 - (2*(-1 + 4*x))/((3 + Sqrt[5] - 2*x)*(-3 + 2*x)) + (2*(-1 + 4*x))/((-3 + 2*x)*(-3 + Sqrt[5] + 2*x)) >, Output] }, Open ]], Cell[CellGroupData[{ Cell[BoxData[ (Simplify[%])], Input], Cell[(x*(1 + x))/(1 - 3*x + x^2), Output] }, Open ]], Cell[Partial fractions will often involve Root objects , Text], Cell[CellGroupData[{ Cell[pf3 = PartialFractionsR[(1 + x)/(x^3 - x + 1), x], Input], Cell[BoxData[ (((1 + Root[1 - #1 + #1^3 &, 1]))/((((x - Root[1 - #1 + #1^3 &, 1])) ((Root[1 - #1 + #1^3 &, 1]^2 - 2 Root[1 - #1 + #1^3 &, 1] Root[(-1) - 2 #1 + 8 #1^3 &, 1] + Root[(-1) + #1^4 + #1^6 &, 2]^2)))) + ((x + Root[1 - #1 + #1^3 &, 1] + x Root[1 - #1 + #1^3 &, 1] - 2 Root[(-1) - 2 #1 + 8 #1^3 &, 1] - Root[(-1) + #1^4 + #1^6 &, 2]^2))/(((((-x^2) + 2 x Root[(-1) - 2 #1 + 8 #1^3 &, 1] - Root[(-1) + #1^4 + #1^6 &, 2]^2)) ((Root[1 - #1 + #1^3 &, 1]^2 - 2 Root[1 - #1 + #1^3 &, 1] Root[(-1) - 2 #1 + 8 #1^3 &, 1] + Root[(-1) + #1^4 + #1^6 &, 2]^2)))))], Output] }, Open ]], Cell[This can in fact be put in radical form:, Text], Cell[CellGroupData[{ Cell[ToRadicals[pf3], Input], Cell[BoxData[ (((1 - ((2/(3 ((9 - @69)))))^(1/3) - ((1/2 ((9 - @69))))^(1/3)/3^(2/3)))/(((((-(1/3)) + 1/3 ((25/2 - (3 @69)/2))^(1/3) + 1/3 ((1/2 ((25 + 3 @69))))^(1/3) + (((-((2/(3 ((9 - @69)))))^(1/3)) - ((1/2 ((9 - @69))))^(1/3)/3^(2/3)))^2 - 2 (((-((2/(3 ((9 - @69)))))^(1/3)) - ((1/2 ((9 - @69))))^(1/3)/3^(2/3))) ((1/24 ((864 - 96 @69))^(1/3) + ((1/2 ((9 + @69))))^(1/3)/(2 3^(2/3)))))) ((((2/(3 ((9 - @69)))))^(1/3) + ((1 /2 ((9 - @69))))^(1/3)/3^(2/3) + x)))) + ((1/3 - 1/3 ((25/2 - (3 @69)/2))^(1/3) - ((2/(3 ((9 - @69)))))^(1/3) - ((1/2 ((9 - @69))))^(1/3)/3 ^(2/3) - 1/3 ((1/2 ((25 + 3 @69))))^(1/3) - 2 ((1/24 ((864 - 96 @69))^(1/3) + ((1/2 ((9 + @69))))^(1/3)/(2 3^(2/3)))) + x + (((-((2/(3 ((9 - @69)))))^(1/3)) - ((1/2 ((9 - @69))))^(1/3)/3^(2/3))) x))/(((((-(1 /3)) + 1/3 ((25/2 - (3 @69)/2))^(1/3) + 1/3 ((1/2 ((25 + 3 @69))))^(1/3) + (((-((2/(3 ((9 - @69)))))^(1/3)) - ((1/2 ((9 - @69))))^(1/3)/3^(2/3)))^2 - 2 (((-((2/(3 ((9 - @69)))))^(1/3)) - ((1/2 ((9 - @69))))^(1/3)/3^(2/3))) ((1/24 ((864 - 96 @69))^(1/3) + ((1/2 ((9 + @69))))^(1/3)/(2 3^(2/3)))))) ((1/3 - 1/3 ((25/2 - (3 @69)/2))^(1/3) - 1/3 ((1/2 ((25 + 3 @69))))^(1/3) + 2 ((1/24 ((864 - 96 @69))^(1/3) + ((1/2 ((9 + @69))))^(1/3)/(2 3^(2/3)))) x - x^2)))))], Output] }, Closed]], Cell[We could have found the inexact form directly., Text], Cell[CellGroupData[{ Cell[BoxData[ (PartialFractionsR[((1 + x))/((x^3 - x + 1)) // N, x])], Input], Cell[BoxData[ ((-(0.07614206365252976`/(((1.324717957244746`)( [InvisibleSpace])) + 1.` x))) + (((0.7982664819556426`)( [InvisibleSpace])) + 0.07614206365252976` x)/(((0.754877666246693`)([InvisibleSpace])) - 1.324717957244746` x + 1.` x^2))], Output] }, Open ]] }, Closed]] }, Open ]] }, ScreenRectangle->{{0, 1024}, {0, 709}}, AutoGeneratedPackage->None, WindowSize->{534, 628}, WindowMargins->{{199, Automatic}, {0, Automatic}}, ShowCellLabel->False, StyleDefinitions -> Default.nb ] XXX -- Allan --------------------- Allan Hayes Mathematica Training and Consulting Leicester UK www.haystack.demon.co.uk hay@haystack.demon.co.uk Voice: +44 (0)116 271 4198 > Greetings MathGroup, > > My name is Steve Earth, and I am a new subscriber to this list and also a > new user of Mathematica; so please forgive this rather simple question... > > I would like to enter the quartic x^4 + x^3 + x^2 + x + 1 into Mathematica > and have it be able to tell me that it factors into > > (x^2 + GoldenRatio x + 1) ( x^2 - 1/GoldenRatio x + 1) > > What instructions do I need to execute to achieve this output? > > -Steve Earth > Harker School > http://www.harker.org/ > Reply-To: kuska@informatik.uni-leipzig.de ==== In[]:=Factor[x^4 + x^3 + x^2 + x + 1, Extension -> {GoldenRatio, 1/GoldenRatio}] Out[]=-((-3 - 2*x + Sqrt[5]*x + GoldenRatio*x - 3*x^2)* (3 + x + Sqrt[5]*x + GoldenRatio*x + 3*x^2))/9 Jens Greetings MathGroup, My name is Steve Earth, and I am a new subscriber to this list and also a > new user of Mathematica; so please forgive this rather simple question... I would like to enter the quartic x^4 + x^3 + x^2 + x + 1 into Mathematica > and have it be able to tell me that it factors into (x^2 + GoldenRatio x + 1) ( x^2 - 1/GoldenRatio x + 1) What instructions do I need to execute to achieve this output? -Steve Earth > Harker School > http://www.harker.org/ ==== > The last part of my message you are quoting was completely wrong, as > was pointed out by Allan Hayes. Mathematica does not track precision of > machine arithmetic computations. In order for Mathematica to give > reliable information about the precision of a computation you have to > explicitly set the precision of all the numerical quantities. > > Your own example at the bottom simply shows you have not understood the > evaluation mechanism of Mathematica. > > Just opposite, thanks to you and other participants, I completely > understood it. SetAccuracy just takes anything and calls it accurate. > This behavior is useless if not stupid. I am not sure I understand what you are referring to as useless if not stupid. The main purpose of SetAccuracy is to allow people who have done their own error analysis to specify the numerical error in an input or in a result. It is often possible through careful numerical analysis, for example, to come up with a better error estimate than can be given by generic rules for propogation of error. Another common use of SetAccuracy is for converting machine numbers or exact numbers into variable-precision numbers in situations when it is desired that a calculation be done using variable-precision arithmetic. Is there some aspect of this that you think is useless if not stupid, or was that remark referring to something else? Dave Withoff Wolfram Research ==== > The more I play with the example the more depressing it gets. Start > with floating point numbers but explicitely arbitrary-precision ones. In[1]:= > a=77617.00000000000000000000000000000; > b=33095.00000000000000000000000000000; In[3]:= > !(333.7500000000000000000000000000000 b^6 + a^2 ((11 a^2 > b^2 - > b^6 - 121 b^4 - 2)) + 5.500000000000000000000000000000 b^8 + > a/(2 > b)) Out[3]= > !((-4.78339168666055402578083604864320577443814`26.6715*^32)) In[4]:= > Accuracy[%] Out[4]= > -6 Due to the manual section 3.1.6: When you do calculations with arbitrary-precision numbers, as > discussed in the previous section, Mathematica always keeps track of > the precision of your results, and gives only those digits which are > known to be correct, given the precision of your input. When you do > calculations with machine-precision numbers, however, Mathematica > always gives you a machine?precision result, whether or not all the > digits in the result can, in fact, be determined to be correct on the > basis of your input. Because I started with arbitrary-precision numbers Mathematica should display > only those digits that are correct, that is none. An accuracy of -6 means that the least significant correct digit is 6 digits to the left of the decimal point. The result Out[3] in the example above has 26 significant digits to the left of that (the most sigificant digit is 26+6=32 digits to the left of the decimal point), so there are 26 correct digits to display. Was there some other result you were referring to as a result in which the number of correct digits is none? Dave Withoff Wolfram Research ==== > I came across this, and thought I would share. This may be OBE if the font > selection is better in 4.2. I'll that installed by this time tomorrow...I > hope. http://cgm.cs.mcgill.ca/~luc/math.html I started reading through this list, and had visions of recursively > downloading the entire internet looking for the font's I really need. > Anybody know what fonts I should have installed on my SuSE box to satisfy > Mathematica's default expectations? The contents of the page at this URL are interesting, but probably not relevant for your purposes. The only fonts which are absolutely needed by the front end are the fonts that supply the special glyphs for mathematical notation, grouping characters, Greek letters, etc. These fonts were developed by Wolfram Research and are installed as part of the Mathematica installation. There are two generations of these fonts. The first generation was introduced in Mathematica 3.0 in the fall of 1996 and were used through the release of Mathematica 4.1. There were five families known as Math1 - Math5. Each familiy had four variants: a proportionaly-spaced medium face, a monospaced medium, a proportional bold, and a monospaced bold. The second generation is used by Mathematica 4.2. There are seven families named Mathematica1 - Mathematica7. Aside from the math fonts, the front end should be able to function properly provided that you have a font that supports the encoding for your chosen locale. The style sheets bundled with the front end use only Times, Helvetica, and Courier. Should these fonts not be available on your system, the front end has some substitution rules. For example, the Windows front end knows to use the fonts Times New Roman, Arial, and Courier New. The X Window System ships with bitmap versions of Times, Helvetica, and Courier as well as an outline of Courier. If one of these fonts must be drawn at a size for which there are no bitmaps, outline fonts provided with Mathematica are used. Helvetica is aliased to Swiss721, and Times is aliased to Utopia through a fonts.alias file in the Mathematica fonts directory. Under MacOS and Windows, you should be albe to use whatever fonts are available on your system. Under X, things are a little more complicated. The front end can display whatever fonts are made available to your X server, but it can generate PostScript only for those fonts where an Adobe Font Metric (AFM) file is available. If you wish to display or print the PostScript, you must also make the Type 1 font file available to the rendering device. Note also that the X front end has an adjustable setting for the amount of memory to reserve for storing font data. If your system has a large number of fonts, you may need to increase this setting per this FAQ page: http://support.wolfram.com/mathematica/systems/linux/interface/fonterrors.ht ml -- User Interface Programmer paulh@wolfram.com Wolfram Research, Inc. ==== > I came across this, and thought I would share. This may be OBE if the >> font >> selection is better in 4.2. I'll that installed by this time >> tomorrow...I hope. >> http://cgm.cs.mcgill.ca/~luc/math.html >> I started reading through this list, and had visions of recursively >> downloading the entire internet looking for the font's I really need. >> Anybody know what fonts I should have installed on my SuSE box to satisfy >> Mathematica's default expectations? The contents of the page at this URL are interesting, but probably not > relevant for your purposes. That's kind'o' what I thought. [snip - history lesson - thanks] > The second generation is used by Mathematica 4.2. There are seven > families named Mathematica1 - Mathematica7. Where is the documentation for installing these? This is dated: http://support.wolfram.com/mathematica/systems/linux/interface/fonterrors.ht ml I grabbed these off the net: http://support.wolfram.com/mathematica/systems/linux/general/latestfonts.htm l http://support.wolfram.com/mathematica/systems/linux/general/MathBDF_42.tar. gz http://support.wolfram.com/mathematica/systems/linux/general/MathPCF_42.tar. gz http://support.wolfram.com/mathematica/systems/linux/general/MathT1_42.tar.g z > su - ****** # cd /usr/X11/lib/X11/fonts/ # mkdir -p local/mma # cd local/mma # tar xvfz /download/com/wri/MathBDF_42.tar.gz # tar xvfz /download/com/wri/MathPCF_42.tar.gz # tar xvfz /download/com/wri/MathT1_42.tar.gz # xemacs /etc/X11/XF86Config .... # grep FontPath /etc/X11/XF86Config FontPath /usr/X11R6/lib/X11/fonts/100dpi:unscaled FontPath /usr/X11R6/lib/X11/fonts/75dpi:unscaled FontPath /usr/X11R6/lib/X11/fonts/CID FontPath /usr/X11R6/lib/X11/fonts/Speedo FontPath /usr/X11R6/lib/X11/fonts/Type1 FontPath /usr/X11R6/lib/X11/fonts/URW FontPath /usr/X11R6/lib/X11/fonts/kwintv:unscaled FontPath /usr/X11R6/lib/X11/fonts/latin2/Type1 FontPath /usr/X11R6/lib/X11/fonts/misc:unscaled FontPath /usr/X11R6/lib/X11/fonts/misc/sgi:unscaled FontPath /usr/X11R6/lib/X11/fonts/truetype FontPath /usr/X11R6/lib/X11/fonts/uni:unscaled FontPath /usr/X11R6/lib/X11/fonts/local/mma/BDF FontPath /usr/X11R6/lib/X11/fonts/local/mma/PCF FontPath /usr/X11R6/lib/X11/fonts/local/mma/T1 # SuSEconfig .... # init 3 [assuming you are already at a TTY console] # init 5 > Aside from the math fonts, the front end should be able to function > properly provided that you have a font that supports the encoding for your > chosen locale. The style sheets bundled with the front end use only > Times, Helvetica, and Courier. Should these fonts not be available on > your system, the front end has some substitution rules. For example, the Windows front end knows to use the fonts Times New Roman, > Arial, and Courier New. The X Window System ships with bitmap versions of > Times, Helvetica, and Courier as well as an outline of Courier. If one of > these fonts must be drawn at a size for which there are no bitmaps, > outline fonts provided with Mathematica are used. Helvetica is aliased to > Swiss721, and Times is aliased to Utopia through a fonts.alias file in the > Mathematica fonts directory. This is what I find anoying. Every time Mathematica does one of these substitutions, it beeps. This is what I'm calling a font fault. It's like the boy who cried wolf. I start ignoring beeps. It also bothers me that I am not seeing what the author had intended. I *believe* it is the author of the notebook or help document who determines what fonts should be used. This is a point of confusion. When I opened a help page, and didn't like the size of the fonts, I tried to adjust them without the desired result. I now believe the proper remedy is to use magnification, not a font adjustment. I have far fewer chirps (beeps) in 4.2, but I do get them when changing the magnification. > Under MacOS and Windows, you should be albe to use whatever fonts are > available on your system. Under X, things are a little more complicated. > The front end can display whatever fonts are made available to your X > server, but it can generate PostScript only for those fonts where an Adobe > Font Metric (AFM) file is available. If you wish to display or print the > PostScript, you must also make the Type 1 font file available to the > rendering device. This is for another day. I believe I have done this in years gone by, but, for now, I just want to get the optimal behavior form the crt. [snip] Here's my question in a nutshell. When I do xlsfonts, what should be listed in order to run Mathematica 4.2 and not experiece font faults generated by content provided on the CD? Please note that I *just* finished installing the fonts off the web, so I'm not sure what, if any problems still remain. I suspect the helvetica faults will still occur. STH . ==== I'm a newbie and, of course, the first thing I want to do is apparently one of the most complicated... I have an expression that looks like this: A + B/C + D*Sqrt[E]/C = 0 A,B,C,D, & E are all polynomials in x I want it to look like this (D^2)*E = (A*C + B)^2 At that point, I'll have polynomials in x on both sides. Finally, I want the equation to be written out with terms grouped by powers of x, but I think I can do that part :) I'll be very grateful to anyone who can give me some pointers. Or, at least point me to some tutorial in the Mathematica documentation. I've been looking over the documentation and I found Appendix A.5 in The Mathematica Book, but that doesn't help me. I _need_ some examples. I did find a couple of well-written posts in this newsgroup, but not quite close enough to what I want. Troy. =-=-=-=-=-=-=-=-=-= FYI, here's the expression I'm working with. denom = Sqrt[(B^2 - r^2)^2 + 4*(r^2)*(b^2)] cnu = (2*b^2 - B^2 + r^2)/denom snu = -2*b*Sqrt[B^2 - b^2]/denom sif = 2*r*b/denom cif = (r^2 - B^2)/denom pdr = -Cos[ds]*Sin[q]*(snu*cif + cnu*sif) - Sin[ds]*(cnu*cif - snu*sif) 0 == -(B^2 - b^2)*V^2/(r^2) + (((B*V)^2)/( r^2) - 2*w*b*V*Cos[q]*Cos[ds] + (w* r)^2 - (w*r*pdr)^2)*(Cos[qr])^2 Although I said it's a polynomial in x, it's really a polynomial in b that I'm after. ==== Troy, True, interactive manipulation can be difficult. However, here is one way to do what you want. We have to do the same thing to both sides of the equation. (# - D*Sqrt[K]/C)&/@(A+B/C+D*Sqrt[K]/C[Equal]0 A + B/C == -((D*Sqrt[K])/C) Together/@% (B + A*C)/C == -((D*Sqrt[K])/C) #C&/@% B + A*C == (-D)*Sqrt[K] #^2&/@% (B + A*C)^2 == D^2*K NOTES. Here is how #C&/@ (lhs ==rhs) works: #C&/@ (lhs ==rhs) --> #C&[lhs]==#C&[rhs] --> lhs C == rhs C --> ... f/@( expr) is special for for Map[f, expr] expr& is special for Function[expr] Please look up Map and Function in the Help Browser. -- Allan --------------------- Allan Hayes Mathematica Training and Consulting Leicester UK www.haystack.demon.co.uk hay@haystack.demon.co.uk Voice: +44 (0)116 271 4198 > I'm a newbie and, of course, the first thing I want to do is apparently > one of the most complicated... > > I have an expression that looks like this: > > A + B/C + D*Sqrt[E]/C = 0 > > A,B,C,D, & E are all polynomials in x > I want it to look like this > > (D^2)*E = (A*C + B)^2 > > At that point, I'll have polynomials in x on both sides. Finally, I > want the equation to be written out with terms grouped by powers of x, > but I think I can do that part :) > > I'll be very grateful to anyone who can give me some pointers. Or, at > least point me to some tutorial in the Mathematica documentation. I've > been looking over the documentation and I found Appendix A.5 in The > Mathematica Book, but that doesn't help me. I _need_ some examples. I > did find a couple of well-written posts in this newsgroup, but not quite > close enough to what I want. > > > Troy. > > =-=-=-=-=-=-=-=-=-= > > FYI, here's the expression I'm working with. > > > denom = Sqrt[(B^2 - r^2)^2 + 4*(r^2)*(b^2)] > cnu = (2*b^2 - B^2 + r^2)/denom > snu = -2*b*Sqrt[B^2 - b^2]/denom > sif = 2*r*b/denom > cif = (r^2 - B^2)/denom > > pdr = -Cos[ds]*Sin[q]*(snu*cif + > cnu*sif) - Sin[ds]*(cnu*cif - snu*sif) > > 0 == -(B^2 - b^2)*V^2/(r^2) + (((B*V)^2)/( > r^2) - 2*w*b*V*Cos[q]*Cos[ds] + (w* > r)^2 - (w*r*pdr)^2)*(Cos[qr])^2 > > Although I said it's a polynomial in x, it's really a polynomial in b > that I'm after. > ==== > Troy, > True, interactive manipulation can be difficult. > However, here is one way to do what you want. > We have to do the same thing to both sides of the equation. (# - D*Sqrt[K]/C)&/@(A+B/C+D*Sqrt[K]/C[Equal]0 A + B/C == -((D*Sqrt[K])/C) I think I have to apologize for the lack of clarity in my original post. I had tried to word it carefully, but I deceived myself. I should have said: I have an expression that can be put into this form: A + B/C + D*Sqrt[K]/C = 0 A,B,C,D, & K are all polynomials in x I need to get it into that form and, in the end, I want it to look like this (D^2)*K = (A*C + B)^2 I think I gave the impression that I have polynomials A,B,C,D, & K at my fingertips. I don't. The expression I have is given at the end of this message. I'm still trying to digest the respones I've garned so far. In the meantime, I decided to post this clarification. > I'm a newbie and, of course, the first thing I want to do is >> apparently one of the most complicated... >> >> I have an expression that looks like this: >> >> A + B/C + D*Sqrt[K]/C = 0 >> >> A,B,C,D, & K are all polynomials in x >> I want it to look like this >> >> (D^2)*K = (A*C + B)^2 >> >> At that point, I'll have polynomials in x on both sides. Finally, I >> want the equation to be written out with terms grouped by powers of x, >> but I think I can do that part :) >> >> I'll be very grateful to anyone who can give me some pointers. Or, >> at least point me to some tutorial in the Mathematica documentation. >> I've been looking over the documentation and I found Appendix A.5 in >> The Mathematica Book, but that doesn't help me. I _need_ some >> examples. I did find a couple of well-written posts in this newsgroup, >> but not quite close enough to what I want. >> >> >> Troy. >> >> =-=-=-=-=-=-=-=-=-= >> >> FYI, here's the expression I'm working with. >> >> >> denom = Sqrt[(B^2 - r^2)^2 + 4*(r^2)*(b^2)] >> cnu = (2*b^2 - B^2 + r^2)/denom >> snu = -2*b*Sqrt[B^2 - b^2]/denom >> sif = 2*r*b/denom >> cif = (r^2 - B^2)/denom >> >> pdr = -Cos[ds]*Sin[q]*(snu*cif + >> cnu*sif) - Sin[ds]*(cnu*cif - snu*sif) >> >> 0 == -(B^2 - b^2)*V^2/(r^2) + (((B*V)^2)/( >> r^2) - 2*w*b*V*Cos[q]*Cos[ds] + (w* >> r)^2 - (w*r*pdr)^2)*(Cos[qr])^2 >> >> Although I said it's a polynomial in x, it's really a polynomial in >> b that I'm after. >> ==== I'm only a little embarassed for not having realized what was happening. (Perhaps I should have slept on it.) Surely I'm not alone in thinking this symbolism is highly nonintuitive. But of course, for it to be otherwise would require another protected symbol... --- Selwyn >>In: DSolve[y*D[u[x, y],x] == x*D[u[x, y],y], u[x,y], {x, y}] >> >>Out: {{u[x, y] -> C[1][(1/2)*(x^2 + y^2)]}} >> >>Square brackets are used as grouping symbols in the result!?? :^O >> >>Somebody say it isn't so. >> > It isn't so The square bracket is not delineating a factor it is enclosing the argument > to an arbitrary function named C[1]. While the function is dependent on both > x and y the dependence only occurs in the combination (x^2+y^2). > Bob Hanlon > Reply-To: ==== It isn't so. The solution is an arbitrary function of (1/2)*(x^2 + y^2)]}}. Bobby -----Original Message----- ==== Does anyone know what happened to the < in Mathematica 4.x? In some version I know I used it, but it seems to > have gone away. It allowed for real time manipulation of 3D graphics. > Ray Gittings ==== it's still there << RealTime3D` but MathGL3d may be the better solution > http://phong.informatik.uni-leipzig.de/~kuska/mathgl3dv3/ Jens >>Does anyone know what happened to the <>in Mathematica 4.x? In some version I know I used it, but it seems to >>have gone away. It allowed for real time manipulation of 3D graphics. >> >> >>Ray Gittings ==== The more I play with the example the more > depressing it gets. Start > with floating point numbers but explicitly > arbitrary-precision ones. In[1]:= > a=77617.00000000000000000000000000000; > b=33095.00000000000000000000000000000; In[3]:= > !(333.7500000000000000000000000000000 b^6 + > a^2 ((11 a^2 > b^2 - > b^6 - 121 b^4 - 2)) + > 5.500000000000000000000000000000 b^8 + > a/(2 > b)) Out[3]= > > !((-4.78339168666055402578083604864320577443814`26.6715*^32)) In[4]:= > Accuracy[%] Out[4]= > -6 Due to the manual section 3.1.6: When you do calculations with arbitrary-precision > numbers, as > discussed in the previous section, Mathematica > always keeps track of > the precision of your results, and gives only > those digits which are > known to be correct, given the precision of your > input. When you do > calculations with machine-precision numbers, > however, Mathematica > always gives you a machine[CapitalEth]precision result, > whether or not all the > digits in the result can, in fact, be determined > to be correct on the > basis of your input. Because I started with arbitrary-precision numbers > Mathematica should display > only those digits that are correct, that is none. No, 26 digits are correct Here is the number: -0.8273960599468213681 Here is the same number computed by Mathematica with 26 correct digits: -4.78339168666055402578083604864320577443814[Times]10^32 It looks like I have been using some wrong definition of correct.:-) You just proved that Precision is useless as a measure how good your numerical result is. > (check Precision instead > of Accuracy to see > this). You appear to be showing output in InputForm. If you > use OutputForm or > StandardForm only 26 digits will be shown. 32 > Out[3]= -4.7833916866605540257808360 10 InputForm is showing more because it exposes bad > digits as well as > good ones. > To relax a bit, set a new input cell to > StandardForm and type > 77617.000000000000000000000000000000000 Convert it to InputForm. You get > > 77616.999999999999999999999999999999999999999999952771`37.9031 Convert back to StandardForm > > 77616.99999999999999999999999999999999999999999976637`37.9031 Again to InputForm > > 77616.99999999999999999999999999999999999999999963735`37.9031 Back to StandardForm > > 77616.99999999999999999999999999999999999999999951376`37.9031 See what you can get if you have enough patience > or a small program. PK Agreed, it's not very pretty. I am uncertain as to > whether this > indicates a bug in StandardForm or elsewhere in the > underlying numerics > code, and will defer to our numerics experts on that > issue. My guess is > it is a bug if only because it violates the spirit > of IEEE arithmetic > wherein floats that have integer values should be > representable as such > (or something to that effect). I will point out, > however, that the two > numbers in question are equal to the specified > precision. Also it > appears to be improved in our development kernel. > Daniel Lichtblau > Wolfram Research __________________________________________________ Do you Yahoo!? http://faith.yahoo.com ==== > You are entitled to your opinion. For my applications > this behavior IS useless. > I agree that Mathematica is probably useless for you. This is however not because it is useless or useless for your application, but because to use its full power you have to study it, understand it, and in particular, for numerical work, understand the model of arithmetic it uses. Lie with mathematics they are really no shortcuts that will lead you to its full power. In addition, since it is a computer program, it has certain conventions, which may not be the same as the conventions of other programs (they all have conventions) but which you have to accept to be able to use it. Now, once you have done that, you may still not like the way Mathematica does things and there are genuine experts in numerics who indeed do not like and are quite vocal about it. But they never say it is useless, because by saying that you are either displaying your own ignorance or engaging in stupid and pointless abuse. On a more serious level, there seem to be two basic approaches to numeric computation relevant to this discussion. It seems to me (though I am no expert in this sort of thing) that there are three types of situations that one may encounter. Firstly, there is the vast majority of rather simple computations for which built-in machine floating point arithmetic , which carries no guarantee of precision at all is meant for. It clearly must be sufficient for the majority of purposes, since most general purpose and even technical software available uses not other method. The reason of course is that it is by far the fastest way to do such computations (as well as being sufficient for most situations). The second type of situation is when you actually know the precision of your input and would like the program to give you some idea about the precision of the output you might expect. This is the most likely situation in empirical science and is exactly what SetPrecision is meant for. Most reasonable people would agree that Mathematica works well in this situation. There is finally one more situation, to which the only reasonable criticism that I have read in this thread appears to be directed at. That is the situation when you actually know your input exactly, but working with exact numbers is far too slow. So what you have to do is to replace your exact numbers with inexact ones padded with 0's. In Mathematica you have to take a guess at how much padding you will need, than use SetPrecision to pad the numbers, and then check the Precision of your answer. It may turn out that you did not get as much precision as you needed, in which case you have to use more zeros. Or it may be that you used more than enough, which mans that your computation could have been done faster. I learned from Leszek Sczaniecki that there is an approach due to Oliver Aberth which lets you only specify the desired precision of your answer and the program itself will choose the correct padding for your input. It woudl ertainly be nice to have this ability, but I honestly think that it would be only of marginal advantage over making your own guess. It seems to me that the checking that the Aberth mthod must require will be time consuming and wiht a bit of practice one can probably get better results as far as speed is concerned using the Mathematica approach. But this is just pure speculation and certainly it woudl be nice if such a possibility existed. Andrzej Kozlowski Toyama International University JAPAN http://sigma.tuins.ac.jp/~andrzej/ ==== >Yes, there seems to be a lot of people who have a visceral hatred for >Microsoft and Windows. They are even willing to shed blood to avoid >Windows. But why? Windows works and you don't have to become a systems >programmer. > >Furthermore, I think that Steven Wolfram uses some version of Windows. >So guess which system Mathematica will be best tuned up for? If it is true Wolfram uses Mathematica on a Windows based machine my experience is it doesn't translate to Mathematica running better on Windows. I use Mathematica on WindowsNT and on a Mac (currently Mac OS X). I have found Mathematica to be more stable on a Mac than on Windows. On more than one occassion I've seen errors I made Mathematica code to crash the entire machine under WindowsNT. I've never had this happen running things on a Mac. ==== >Yes, there seems to be a lot of people who have a visceral hatred for >>Microsoft and Windows. They are even willing to shed blood to avoid >>Windows. But why? Windows works and you don't have to become a systems >>programmer. >> >>Furthermore, I think that Steven Wolfram uses some version of Windows. >>So guess which system Mathematica will be best tuned up for? If it is true Wolfram uses Mathematica on a Windows based machine my > experience is it doesn't translate to Mathematica running better on > Windows. I use Mathematica on WindowsNT and on a Mac (currently Mac OS X). > I have found Mathematica to be more stable on a Mac than on Windows. On > more than one occassion I've seen errors I made Mathematica code to crash > the entire machine under WindowsNT. I've never had this happen running > things on a Mac. I believe you hit the nail on the head. I suspect Dr. Wolfram is running on Mac. I have the feeling WRI is a clandestine Mac holdout. STH . ==== I ran Turbo XML http://www.tibco.com/solutions/products/extensibility/turbo_xml.jsp on ToFileName[{$TopDirectory, SystemFiles, IncludeFiles, XML}, notebookml1.dtd ] It gave me an error saying: There is more than one attribute named class. My guess is this was the intention: hattons@ljosalfr:~/.Mathematica/SystemFiles/IncludeFiles/XML/NotebookML1> diff /opt/Wolfram/Mathematica/4.2/SystemFiles/IncludeFiles/XML/NotebookML1/notebo okml.dtd /home/hattons/.Mathematica/SystemFiles/IncludeFiles/XML/NotebookML1/notebook ml.dtd 91c91 Comments? STH . ==== I've posted Mathematica notebooks and packages illustrating most of the neural networks discussed in James Anderson's book An Introduction to Neural Networks to the Brainstage Research web site (www.brainstage.com). Have fun! Don Donald Doherty, Ph.D. Brainstage Research, Inc. donald.doherty@brainstage.com ==== can I have mathematica solver things like a(over)b, (in how many ways can you pick b items from a items)? I have mathematica 4. Stefan ==== Stefan You certainly can - try Binomial[a,b]. Mark Westwood > can I have mathematica solver things like a(over)b, (in how many ways > can you pick b items from a items)? I have mathematica 4. Stefan ==== There are two basic ways, the second of which has two forms. The basic ways are: 1. Using the built in function ContourPlot, e.g.: ContourPlot[x^3y + y^3 - 9, {x, -9, 9}, {y, -27, 27}, Contours -> {0}, ContourShading -> False, Axes -> True, Frame -> False, PlotPoints -> 50, AxesOrigin -> {0, 0}] alternatively you can use a Standard package: <{0,0}] or ImplicitPlot[x^3y+y^3-==9,{x,-9,9},{y,-27,27},AxesOrigin->{0,0}] The difference between these two is that the first one gives you a smoother picture but requires the equation to be solvable (by Mathematica) for y. The second will give a picture very similar to that produced by the first method. Andrzej Kozlowski Yokohama, Japan http://www.mimuw.edu.pl/~akoz/ http://platon.c.u-tokyo.ac.jp/andrzej/ > How can I plot functions like: > > (x-2)^2 + 2(y-3)^2 = 6 > > and > > x^3y + y^3 = 9 > > using Mathematica? > > > > > > ==== Since you already know the answer, the simplest way is: In[51]:= Factor[x^4 + x^3 + x^2 + x + 1, Extension -> {GoldenRatio}] Out[51]= (-(-1 - x + GoldenRatio*x - x^2))*(1 + GoldenRatio*x + x^2) Andrzej Kozlowski Yokohama, Japan http://www.mimuw.edu.pl/~akoz/ http://platon.c.u-tokyo.ac.jp/andrzej/ > Greetings MathGroup, > > My name is Steve Earth, and I am a new subscriber to this list and > also a > new user of Mathematica; so please forgive this rather simple > question... > > I would like to enter the quartic x^4 + x^3 + x^2 + x + 1 into > Mathematica > and have it be able to tell me that it factors into > > (x^2 + GoldenRatio x + 1) ( x^2 - 1/GoldenRatio x + 1) > > What instructions do I need to exec