A39
====
Aim___The use of Mathematica in statistics is
currently undergoing arenaissance. This special issue of The
Mathematica Journal will bedevoted to all aspects of
statistics. Any paper related to statisticsis welcome,
irrespective of whether the focus is theoretical orapplied,
symbolic or numerical, and specifically including
softwaredemos, from authors who have backgrounds in
statistics, probability,computer science, mathematics,
econometrics, psychometrics,computational biology,
etcSubmission Guidelines_____________________Papers must be
written in English and submitted as Mathematicais no absolute
restriction on length. However, shorter papers (6 to 10pages)
will be strongly preferred to longer ones, in the interest
ofdiversity and quality. Authors are requested to be as
concise aspossible. Long code listings can easily be included
in the electronicversion of the journal.All submitted papers
will be refereed. Submitting authors may be askedto referee a
paper.Please also see the journalÕs submissions page:
http://www.mathematica-journal.com/submissions/OF INTENT
(author details, tentative title, and an estimated number
ofpages) as soon as possible to the guest editor at
colin@mathStatica.com_______________Statement of Intent: 30
November (preferred) to 30 December 2002Submission of paper:
31 JanuaryRefereeing: February/March 2003
(tentative)Revision: April 2003Publication: September
2003
====
Huh??? The last element of y should be
1000000 while the last element of x should be 2.Possibly the
difference is because one is stored as a packed array and the
other isnÕt.try Developer`PackedArrayQ[x] and
Developer`PackedArrayQ[y]
====
You can see the difference as
follows:In[17]:=<<Developer`In[18]:= x =
Table[2.,{i,100000}];In[19]:=PackedArrayQ[x]Out[19]=TrueIn[20
]:=y =
Table[If[i<1000000,2.,i],{i,100000}];In[21]:=PackedArrayQ[y]
Out[21]=FalseTHe need to unpack a packed array makes the first
code run slower.Andrzej KozlowskiYokohama,
Japanhttp://www.mimuw.edu.pl/~akoz/http://
platon.c.u-tokyo.ac.jp/andrzej/
====
x =
Table[2.,{i,100000}];creates a Packed Array buty =
Table[If[i<1000000,2.,i],{i,100000}];doesnÕt. The 
Mathematica
documentation says:When appropriate, large lists and nested
lists of numbers areautomatically stored as packed arrays of
machine-sized integersor real numbers.Does anyone know
anymore details about what Mathematica considersappropriate
in this context? When fine-tuning code 
forefficiency, it would
be nice to be able to predict what datastructures Mathematica
is creating.
====
I tried executing your snippet and wound up
with an Unable to fit initial boundary conditions 
error.WhatÕs
wrong? Jan M. (Ō_Õ) P.S. If your interest is 
only in the
numerical evaluation of the DE, I suggest you use NDSolve[]
instead.Did you mean this?DSolve[{A1 x^2 
yÕÕ[x]+A2 x^2
yÕ[x]^2+A3 x y[x] y[x]==A4 x^3 y[x]^4+A5 x^2
y[x]^3,yÕ[0]==0,y[a]==A6},y[x],x]ToddLC 
====
Hi,1)in the
following example len1 and len2 are assigned
values.In[2]=status = {len1, len2}status1 = {3, 4};{len1,
len2} = status1;Print[status: , status];Print[len1: , len1,
len2: , len2]Out[2]= {len1, len2}status: {3, 4}len1: 3 len2:
4In[7]:=2)In this example, len1 and len2 are not assigned
values, because status1 isassigned to status
directly.In[2]=status = {len1, len2}status1 = {3, 4};status =
status1;Print[status: , status];Print[len1: , len1, len2: ,
len2]Out[2]= {len1, len2}status: {3, 4}len1: len1 len2:
len2In[7]:=My question is:Can the result of example 1) be
achieved in any way using the variablesstatus and
status1Hermann Schmitt
====
MathROOT is a tool for high-energy
physicists to access the ROOT dataanalysis framework from
within Mathematica. This is the first release ofMathROOT to
the community and will allow ROOT userÕs to analyze 
theirdata
from the comfort of MathematicaÕs notebook interface instead
ofROOTÕs CINT command line interface.More information about
MathROOT is available at the MathROOT web
sitehttp://mathroot.sourceforge.net. An example Mathematica
notebook showingsome of MathROOTÕs features is available for
online viewing
athttp://mathroot.sourceforge.net/example/index.html. More
informationabout ROOT is available at http://root.cern.ch.
More information aboutMathematica is available at
http://www.wolfram.com.This release of MathROOT includes the
following features:* Quickly access data in ROOT trees using
either simple column names (i.e. TLeaf names) or ROOTÕs
proprietary expression/query language. The data to return,
the selection criteria to apply to the data and the number of
events can all be specified, similar to ROOTÕs 
TTree::Draw
functionality.* ROOT data is returned to Mathematica in
MathematicaÕs native data format: ROOT integer types (e.g.
Int_t, UInt_t) map to Mathematica Integer type, and ROOT ßoat
types (e.g. Float_t, Double_t) map to MathematicaÕs Real
type.* ROOT arrays are fully supported, both multidimensional
arrays and ROOT array slices. Array results are returned in
MathematicaÕs native nested list structure, which makes it
easy to instantly leverage MathematicaÕs powerful data
analysis functionality to all ROOT data.* Only those tree
columns that appear in the query are returned to Mathematica,
which makes accessing subsets of even the largest ROOT data
stores fast.* MathROOT can return extensive meta-data about
ROOT files and trees (i.e. column names, column types, number
of events in a TTree, etc.). This makes it easy to quickly
scan multiple ROOT data stores for information.The initial
release of MathROOT 0.8.2.0 includes source code andbinaries
for Windows. The files may be downloaded
athttps://sourceforge.net/project/showfiles.php?group_id=69694
.MathROOT is written in portable C++ and can therefore be run
on anycomputer that can run Mathematica and ROOT. However, the
primarydevelopment platform is Windows, so this initial
release only includesVisual Studio.NET solution files which
will only run on Windows. Itshould be straightforward to
integrate Autoconf, Automake, and Libtoolthese needs are
welcome and most appreciated.
====
A series of OOP experiments
in Mathematica.msg#3 - Component, part#1: Inspiration.Ha! I
found out that Google Groups has this newsgroup archived, so
I wasable to search the prior discussions about OOP in
Mathematica.One comment caught my eye -even purely functional
programmers might be interested in wrapping afunctional
package into a Component.So, while I am going to continue to
discuss programming in the small - onthe way to OOP - if that
doesnÕt interest you, then think of it as anexploration that
will lead to making great Components in Mathematica.- - - - -
- - - - -Discussion:Type (including Interface) and Contract
are at the heart of ComponentProgramming.So is Unification of
data and function. Therefore, a component hasstrong
similarities to an object.To be continued...-- Steve S. Shaw
(ToolmakerSteve)
====
A series of OOP experiments in
Mathematica.msg#2 - The Stack, part#6: Timing.Append or
Prepend results in Order^2 timing.(n-squared: pushing ten
times as many items would take one hundred times aslong).He
suggested using nested lists.That is, {a, {b, {c} } } or { {
{a}, b}, c}.I had thought Append would give me an internal
structure like this - but Iwas thinking of Lisp cons - I did
not understand that Mathematica wasstoring in an array, so it
kept having to copy my longer and longer
arrays.------------------------------------------------------
---------------------Discussion: I am not yet talking about
OO; rather I am poking at thefundamentals of how to design
software well.The point here is the use of abstraction: the
implementation of stackSHOULD NOT EXPOSE TO A CLIENT THE
INTERNAL STRUCTURE OF THE STACK.Because I only touched my
stacks using the carefully-designed functions(new, isEmpty,
top, push, drop), I can now change the implementation
freely.In this case, to get better performance.This is the
essence of a Type -whether an OO type with inheritance,or a
simple custom type such as my STACK,or simply a pre-defined
Type such as Integer.NOTE: Since Mathematica doesnÕt protect
me, if I had been using my firstimplementation of stack for a
long time, I could well have writtensubstantial code that
relied on that returned stack structure.That is, since my
stack was a simple array, I might have used arrayoperations
to get at elements in the stack.For example, at some random
place in some random project,I might write an operator that
added the top two items on the stack.If I knew those were the
first two items in an array, I might, withoutthinking about 
it,
dos[[1]] + s[[2]But that shortcut would suddenly break, if the
stack implementation werechanged. Therefore, I would never
dare change the stack implementation.Then along comes someone
who observes that my stack logic is very slow forlarge stacks.
Uh-oh.In the undisciplined programming style possible (and
probable) inMathematica, I wouldnÕt have a clue what I might
break if I tinkered with mystack implementation.My goal is
code that is easily UNDERSTOOD, and easily CHANGED.I am even
willing to put *reasonable* extra effort into writing the
code inthe first place, to achieve that goal.Ever tried to
READ a large program written by someone else (except for
therare person who methodically organizes and thoroughly
documents what theyhave done)?Yuk.So, letÕs explore ways to
be more disciplined in Mathematica.This is more important to
me than that the solution be OO.But the solutions I know
revolve around notions of Type and
Contract.----------------------------------------------------
-----------------------Details: push[ s, x ]:= STACK[x, s]I
am using a head of STACK, so my stack structure looked
likethis (after 3 pushes):STACK[ a, STACK[ b, STACK[ c,
STACK[] ] ] ]Result:The program hardly sped up at all.
:-(Reason:*** nesting heads that are undefined symbolsslows
Mathematica down to about Order^1.5on this simple nesting of
lists!!!- - - - -Solution:STACK=stack;Result:Instantly, the
nested list solution zoomed up in speed. Indeed, it is
nowOrder^1 (linear).The timing test (timing2 is defined below
the -----): timing2[ (sa=new[];Do[sa = push[sa,i],
{i,#}])&,100000 ]Output:{iters[100000,200000], times[0.601
Second,1.192 Second],
ratios[2,1.98336],Order^0.987947}100,000 pushes after the
change took about as long as 2,000 pushes beforethe
change!Caution: if try this timing test with STACK
undefined,use a much smaller number of iterations, such as
2000.Some timing
tests:-------------------------------------------------------
--------------------(* TIMING utility *)timing2[
func_,iter1_,iterRatio_ ]:= Module[
{iter2,time1,time2,timeRatio}, iter2=iter1*iterRatio;
time1=Timing[ func[ iter1 ] ][[ 1 ]]; If[
(time1/Second)<0.0001 , *** Increase iterations//Print,
(time2=Timing[ func[ iter2 ] ][[ 1 ]]; timeRatio=time2/time1;
{iters[iter1,iter2],times[time1,time2],ratios
[iterRatio,timeRatio], ) ] ]timing2[ func_,iter1_ ]:=timing2[
func,iter1,2 ]In[4]:=timing2[ (sa={};Do[sa = {sa,i},
{i,#}])&,200000 ]Out[4]={iters[200000,400000],times[0.491
Second,1.101 Second],
ratios[2,2.24236],Order^1.16502}In[5]:=timing2[ (sa={};Do[sa
= {i,sa}, {i,#}])&,200000 ]Out[5]=
{iters[200000,400000],times[0.651 Second,1.072 Second],
ratios[2,1.6467],Order^0.719575}In[6]:=timing2[ (sa={};Do[sa
= Prepend[ sa,i ], {i,#}])&,3000 ]Out[6]=
{iters[3000,6000],times[0.46 Second,1.583 Second],
ratios[2,3.4413],Order^1.78296}In[7]:=timing2[ (sa={};Do[sa =
Append[ sa,i ], {i,#}])&,3000 ]Out[7]=
{iters[3000,6000],times[0.32 Second,1.522 Second],
ratios[2,4.75625],Order^2.24982}In[8]:=Clear[ STACK
];timing2[ (sa=STACK[];Do[sa = STACK[sa,i], {i,#}])&,2000
]Out[9]= {iters[2000,4000],times[0.211 Second,0.981 Second],
ratios[2,4.64929],Order^2.21701}In[10]:=STACK=stack;In[11]:=
timing2[ (sa=STACK[];Do[sa = STACK[sa,i], {i,#}])&,100000
]Out[11]= {iters[100000,200000],times[0.28 Second,0.591
Second], ratios[2,2.11071],Order^1.07773}In[12]:=timing2[
(sa=STACK[];Do[sa = STACK[i,sa], {i,#}])&,100000 ]Out[12]=
{iters[100000,200000],times[0.391 Second,0.611 Second],
ratios[2,1.56266],Order^0.644004}----------------------------
-----------------------------------------------Revised stack
notebook:----------------------------------------------------
-----------------------Notebook[{Cell[BoxData[ ((( (* Quiet
the warnings about similarly spelled ((variables)(.)) *)
)(n)(Off[General::spell]; Off[ General::spell1];)))],
Input],Cell[BoxData[ ((( (* TIMING utility *)
)([IndentingNewLine])([IndentingNewLine])(timing2[ func_,
iter1_, iterRatio_ ] := [IndentingNewLine]Module[ {iter2,
time1, time2, timeRatio}, [IndentingNewLine]iter2 =
iter1*iterRatio; [IndentingNewLine]time1 = (Timing[ func[
iter1 ] ])[([ 1 ])]; [IndentingNewLine]If[ ((time1/Second)) <
0.0001 , [IndentingNewLine]<*** Increase Print,
[IndentingNewLine]((time2 = (Timing[ func[ iter2 ] ])[([ 1
])]; [IndentingNewLine]timeRatio = ToString[ Log[ timeRatio ]
/ Log[ iterRatio ]
]}[IndentingNewLine]))[IndentingNewLine]][IndentingNewLine]][
IndentingNewLine][IndentingNewLine] timing2[ func_, iter1_ ]
:= timing2[ func, iter1, 2 ])))], Input],Cell[BoxData[ (((
(*(===)(===)(===)(===)(===)(===)(===)(===)(===)(===)(===)(===
)(===)([Equal])*) )([IndentingNewLine])( (*(-- AXIOMS) - True
for all stacks . --*) )([IndentingNewLine])((axiom1[] :=
empty[ new[] ];)[IndentingNewLine] (axiom2[ s_STACK, x_ ] :=
(! empty[ push[ s, x ] ]);)[IndentingNewLine] (axiom3[
s_STACK, x_ ] := ((top[ push[ s, x ] ] ==
x));)[IndentingNewLine] (axiom4[ s_STACK, x_ ] := ((drop[
push[ s, x ] ] == s));)[IndentingNewLine] (allAxioms[
s_STACK, x_ ] := (([IndentingNewLine]axiom1[] && axiom2[ s, x
] && axiom3[ s, x ] && axiom4[ s, x ]));))))],
Input],Cell[CellGroupData[{Cell[BoxData[ (((
(*(===)(===)(===)(===)(===)(===)(===)(===)(===)(===)(===)(===
)(===)([Equal])*) )([IndentingNewLine])( (*(-- an) example of
stack (usage --)*) )([IndentingNewLine])((s1 =
new[];)[IndentingNewLine] (s2 = push[ push[ push[ s1, x1 ],
x2], x3 ];)[IndentingNewLine] (s3 = drop[ s2
];)[IndentingNewLine] (s4 = new[];)[IndentingNewLine] (s5 =
push[ push[ s4, x4 ], x5 ];)[IndentingNewLine] (s6 = drop[ s5
];)[IndentingNewLine] (v1 = top[ s6 ];)[IndentingNewLine] (s7
= push[ s3, v1 ];)[IndentingNewLine] (s8 = push[ s7, x6
];)[IndentingNewLine] (s9 = drop[ s8 ];)[IndentingNewLine]
(s10 = push[ s9, x7 ];)[IndentingNewLine] (s11 = drop[ s10
];)[IndentingNewLine] (result1 = top[ s11
];)[IndentingNewLine] result1[IndentingNewLine] (* MUST BE
TRUE for any implementation of STACK *) [IndentingNewLine]
(stackVerify = ((result1 [Equal] x4));))))],
Input],Cell[BoxData[ (top[ drop[push[ drop[push[
push[drop[push[push[push[new[], x1], x2], x3]],
top[drop[push[push[new[], x4], x5]]]], x6]], x7]]])],
Output]}, Open ]],Cell[BoxData[ ((( (* TBD - True, report
((error)(.))[IndentingNewLine]*)
)([IndentingNewLine])(assert[ test_, message_ ] := If[ (!
TrueQ[ ToString[ message ] // Print ];)))],
Input],Cell[BoxData[ (((
(*(===)(===)(===)(===)(===)(===)(===)(===)(===)(===)(===)(===
)(===)([Equal])*) )(of (Stack --)*)
)([IndentingNewLine])((Clear[ empty, top, new, push, drop,
STACK ];)[IndentingNewLine] was MUCH slower - and was
Order^1.5*) [IndentingNewLine] (*(-- (Queries --))*)
[IndentingNewLine] (empty[ s_STACK ] := ((Length[ s ] [Equal]
0));)[IndentingNewLine] (top[ s_STACK ] :=
(([IndentingNewLine]assert[ (! empty[[IndentingNewLine]First[
s ][IndentingNewLine]));)[IndentingNewLine] (*(-- (Changes
--))*) [IndentingNewLine] (new[] :=
STACK[];)[IndentingNewLine] (push[ s_STACK, x_ ] := STACK[ x,
s ];)[IndentingNewLine] (drop[ s_STACK ] :=
(([IndentingNewLine]assert[ (! empty[[IndentingNewLine]Last[
s ][IndentingNewLine]));))))],
Input],Cell[CellGroupData[{Cell[BoxData[{ (s1),
[IndentingNewLine], (s2), [IndentingNewLine], (result1),
[IndentingNewLine], ((assert[[IndentingNewLine], (allAxioms[
new[], xx ]), [IndentingNewLine], (allAxioms[ s1, xx ]),
[IndentingNewLine], (allAxioms[ s11, xx ])}],
Input],Cell[BoxData[ (stack[])], Output],Cell[BoxData[
(stack[x3, stack[x2, stack[x1, stack[]]]])],
Output],Cell[BoxData[ (x4)], Output],Cell[BoxData[
(allAxioms[stack[], xx])], Output],Cell[BoxData[
(allAxioms[stack[], xx])], Output],Cell[BoxData[
(allAxioms[stack[x4, stack[x2, stack[x1, stack[]]]], xx])],
Output]}, Open ]],Cell[CellGroupData[{Cell[BoxData[ ((( (*
Deliberate errors *) )([IndentingNewLine])(top[ s1
][IndentingNewLine] drop[ s1 ])))], Input],Cell[BoxData[
(***Error: stack.top- empty)], Print],Cell[BoxData[
(First::first ((:)( )) !(stack[]) has a length of zero and no
first element.)], Message],Cell[BoxData[ (First[stack[]])],
Output],Cell[BoxData[ (***Error: stack.drop- empty)],
Print],Cell[BoxData[ (Last::nolast ((:)( )) !(stack[]) has a
length of zero and no last element.)], Message],Cell[BoxData[
(Last[stack[]])], Output]}, Open
]],Cell[CellGroupData[{Cell[BoxData[ StyleBox[(timing2[ ((sa
= new[]; Do[sa = push[sa, i], {i, #}])) &, 100000 ] //
Print;),Cell[BoxData[ ({iters[100000, 200000],
times[0.6010000000000002` Second, 1.1919999999999997`
Second], ratios[2, 1.9833610648918458`], Order^0.987947})],
Print]}, Open ]]},]
====
Sorry. I had a typo in the snippet I
gave. It should have beenIn[1]:= pts=Table[Sin[u], {u,0,2 Pi,
Pi/30}]; In[2]:= ListPlot[pts]; Jan M. (^_^)In[1]:=
pts=Table[Sin[u], {u,0,2 Pi, Pi/0}]; In[2]:= ListPlot[pts];
YouÕd have to wrap Evaluate[] around pts if you 
donÕt want to
get a bunch of error messages . If you want first-hand
experience of how it would be if ListPlot had the HoldAll
attribute, execute this: In[3]:= Unprotect[ListPlot];
SetAttributes[ListPlot, HoldAll]; Protect[ListPlot]; and try
to execute the commands I gave previously. Jan M. (^_^)
Attributes[ListPlot]{Protected}Attributes[Plot]{HoldAll,
Protected}I do not know why Mathematica is inconsistent
here.David
Parkdjmp@earthlink.nethttp://home.earthlink.net/~djmp/Plot[x^
2,{x,0,5}, optionB]Plot[x^2,{x,0,5}, Evaluate[optionB]]???
why is this so????Why must I wrap Evaluate around my options
in Plot?thanksMikeps. This is with version 4.0.2 on a G4
power Mac.
====
Todd,and pasted it, which takes longer than the
instruction you
provided.DianaCSV]theto10,11,12,toExcel..
.23,34,45,56,17,43,60,32,21,58,36,47,32,19,54,41,36,46,21,60,

====
There seems to be a bug in PolynomialReduce. I want to
write 1 as alinear combination (with polynomial coefficients)
of polynomials, saya list
polys={poly1,poly2,poly3,poly4...}.I use the command
PolynomialReduce[1,{poly1,poly2,poly3,...},{x,y}],but it
returns {{0,0,0,...},1}, which is not what I
want.Groebner[{poly1,poly2...},{x,y}] returns {{1}}. What is
wrong withwhat I am doing?
====
Andrzej,You sayHowever, when I
ran your code with version 4.2 for Microsoft Windows (June5,
2002) the expected answer was given: eq = 10^3*b + 10^2*a +
10*s + e + 10^3*b + 10^2*a + 10*l + l - 10^4*g - 10^3*a -
10^2*m - 10*e - s; ss = And @@ Union[DeleteCases[Flatten[
(TrueQ[Simplify[First[#1] == First[#2]]] & )];
Timing[NMinimize[{Abs[eq], 0 <= a <= 9 && 1 <= b <= 9 && 0 <=
e <= 9 && 1 <= g <= 9 && 0 <= l <= 9 && 0 <= m <= 9 && 0 <= s
<= 9 && (a | b | e | g | l | m | s) [Element] Integers &&
ss}, Variables[eq]]]The calculation was slightly quicker with
the ss1, calculated below, inplace of ss <<
DiscreteMath`Combinatorica` ss1 = Abs[Times @@
Apply[Subtract, KSubsets[ Timing[NMinimize[{Abs[eq], 0 <= a
<= 9 && 1 <= b <= 9 && 0 <= e <= 9 && 1 <= g <= 9 && 0 <= l
<= 9 && 0 <= m <= 9 && 0 <= s <= 9 && (a | b | e | g | l | m
| s) [Element] Integers, ss1}, Variables[eq]]]
====
Cool - this
is the kind of solution I was looking for - now I just have
toread the book and interpret it (my problem, not yours :-)I
appreciate your taking the time to provide
it.David--____________________________Dr. David H.
JamesonFounder and CTODigiPortal Software Inc.ThereÕs too
much spam out there.Protect yourself with
ChoiceMailhttp://www.digiportal.comthis
====
It seems to me
that there should be a significantly simpler way to solvethis
problem. I was hoping that Mathematica could do it more
cleanly.D--____________________________
====
I know how to
solve these problems using the methods you suggest - the
goalactually was to use this problem as a driver to help me
learn theMathematica paradigm. IÕm still trying to 
understand
what Mathematica is(and isnÕt) capable of
doing.D--____________________________Dr. David H.
JamesonFounder and CTODigiPortal Software Inc.ThereÕs too
much spam out there.Protect yourself with
ChoiceMailhttp://www.digiportal.combest
====
Actually, I made a
mistake in my message by copying the wrong code from my
notebook. The code:NMinimize[{Abs[eq], a == 4 && 0 <= b <= 9
&& 0 <= e <= 9 && 1 <= g <= 9 && 0 <= l <= 9 && 0 <= m <= 9
&& 0 <= s <= 9 && ss && Element[a | b | e | g | l | m | s ,
Integers]}, Variables[eq]]also works on my machine, what does
not work is:NMinimize[{Abs[eq], 0<=a<=9 && 1 <= b <= 9 && 0 <=
e <= 9 && 1 <= g <= 9 && 0 <= l <= 9 && 0 <= m <= 9 && 0 <= s
<= 9 && ss && Element[a | b | e | g | l | m | s , Integers]},
Variables[eq]]However, the latter code seem to work on 
AllanÕs
Microsoft Windows version of 4.2, which isnÕt any newer than
mine (?)Andrzej KozlowskiYokohama,
Japanhttp://www.mimuw.edu.pl/~akoz/http://
platon.c.u-tokyo.ac.jp/andrzej/
====
OK - I think I mostly
understand this algorithm. A couple of questions.*) IÕd like
to be able to generalise it so that itÕs not limited to
thisparticular sum (base+ball=games). Can the 
Ō5'in the first
line be changedso that it is calculated from the argument list
rather than beinghard-coded?*) Same for the Ō7'
in the MatchQ
function*) Same for the Ō5'in the Table 
function*) As well
as the result, how can we display the value of each
character,which is in fact the real goal?Finally, I note that
a little Ōmanual'work was done to determine 
whichcharacters
are in the operands but not in the result. It would be nice
ifthis could also be Ōcalculated'so that one 
could simply
feed this programthe string base+ball=gamesand have the
result figured out.David--____________________________Dr.
David H. JamesonFounder and CTODigiPortal Software
Inc.ThereÕs too much spam out there.Protect yourself with
ChoiceMailhttp://www.digiportal.comthis
====
I evaluated the
notebook below in a fresh kernel and this time it worked
perfectly. I had to pinch myself to confirm I was not
dreaming, but I can swear it did not work yesterday.Andrzej
CreatedBy=ÕMathematica 4.2'
Mathematica-Compatible
NotebookThis notebook can be used with any
Mathematica-compatibleapplication, such as Mathematica,
MathReader or Publicon. The datafor the notebook starts with
the line containing stars above.To get the notebook into a
Mathematica-compatible application, doone of the following:*
Save the data starting with the line of stars above into a
file with a name ending in .nb, then open the file 
inside the
application;* Copy the data starting with the line of stars
above to the clipboard, then use the Paste menu command
inside the application.Data for notebooks contains only
printable 7-bit ASCII and can beCR, LF or CRLF (Unix,
Macintosh or MS-DOS style).NOTE: If you modify the data for
this notebook not in a Mathematica-compatible application,
you must delete the line below containingtry to use invalid
cache data.For more information on notebooks and
Mathematica-compatibleapplications, contact Wolfram Research:
web: http://www.wolfram.com phone: +1-217-398-0700
(U.S.)Notebook reader applications are available free of
charge fromWolfram
Research.****************************************************
***************)(*
NotebookFileLineBreakTestNotebookFileLineBreakTest*)(*
NotebookOptionsPosition[ 3922,
109]*)(*NotebookOutlinePosition[ 4579, 132]*)(*
CellTagsIndexPosition[ 4535,
128]*)Notebook[{Cell[BoxData[{(<< NumericalMath`NMinimize`;),
[IndentingNewLine], StyleBox[(eq = 10^3 b + 10^2 a + 10 s + e
+ 10^3 b + 10^2 a + 10 l + l - 10^4 g - 10^3 a - 10^2 m - 10
e - s;), And @@ Union[ DeleteCases[ Flatten[ Outer[Abs[#1 -
#2] [GreaterEqual] 1 &, Variables[eq], Variables[eq]]],
False], SameTest [Rule] ((TrueQ[ Simplify[ First[#1] [Equal]
First[#2]]] &))];)}],
Input],Cell[CellGroupData[{Cell[BoxData[
StyleBox[(NMinimize[{Abs[eq], a == 4 && 0 <= b <= 9 && n 0 <=
e <= 9 && 1 <= g <= 9 && 0 <= l <= 9 && n 0 <= m <= 9 && 0 <=
s <= 9 && ss && n Element[ a | b | e | n g | l | m | s ,
Integers]}, Variables[eq]]),Cell[BoxData[ ({0.`, {a [Rule] 4,
b [Rule] 7, e [Rule] 3, g [Rule] 1, l [Rule] 5, m [Rule] 9, s
[Rule] 8}})], Output]}, Open
]],Cell[CellGroupData[{Cell[BoxData[
StyleBox[(NMinimize[{Abs[eq], 0 <= a <= 9 && 1 <= b <= 9 && n
0 <= e <= 9 && 1 <= g <= 9 && 0 <= l <= 9 && n 0 <= m <= 9 &&
0 <= s <= 9 && ss && n Element[ a | b | e | n g | l | m | s ,
Integers]}, Variables[eq]]),Cell[BoxData[ ({0.`, {a [Rule] 4,
b [Rule] 7, e [Rule] 3, g [Rule] 1, l [Rule] 5, m [Rule] 9, s
[Rule] 8}})], Output]}, Open
]]},](*******************************************************
************the top of the file. The cache data will then be
recreated whenyou save this file from within
Mathematica.*************************************************
******************)(*CellTagsOutline*)(*CellTagsIndex*)(*
NotebookFileOutlineNotebook[{Cell[1754, 51, 685, 16, 171,
Input],Cell[CellGroupData[{Cell[2464, 71, 558, 11, 91,
Input],Cell[3025, 84, 141, 2, 27, Output]}, Open
]],Cell[CellGroupData[{Cell[3203, 91, 559, 11, 91,
Input],Cell[3765, 104, 141, 2, 27, Output]}, Open
]]}]*)(******************************************************
*************End of Mathematica Notebook
file.*********************************************************
**********)
====
I am relatively new to mathematica and trying
to output solution of a systemof differential equations from
DSolve in tabular form. For example, if x,vare the dependent
variable and t is the independent variable, how do Ioutput
results in a table of t vs x,v values? DSolve gives results
as How do I convert this to a table of values for t,x,v?N.
Aydemiraydemirn@aecl.ca
====
 Hi All, Is it possible to make
TeXForm not bother about spaces ? Rita Bijlsma
====
Dear
Barbara Da Vinci:webMathematicaDid you set the appropriate
line in your autoexec.bat file, e.g.,set CLASSPATH=C:Program
FilesWolframResearchMathematica4.1AddOnsApplicationsJLinkSyste
mAdditionsJLink.jar;%CLASSPATH%IÕll try to look at this 
later
this weekend and reply to your individualparticular
list.Steven Shippee
====
I am interested in Mathematica.I would
like to know that can I creating any 3d objects or scenes with
mathematica? What editor should I using?Zhang Xianying
====
Are
you saying that you do have some code running in Mathematica,
it justisnÕt giving a result that seems ideal?If so, how 
about
posting the code, the sample data, and the output?Perhaps
someone can see an improvement to make...-- Steve S. Shaw
(a.k.a. ToolmakerSteve)
====
HereÕs a more robust estimation
method for fitting a circle to data.IÕll use 
NigelÕs code to
set things up:r0 = 3.3; x0 = 1.2; y0 = 3.4; sigmar = .3; n =
50;t = Map[{x0 + (r0 + #[[1]])Sin[#[[2]]], y0 + (r0 +
#[[1]])Cos[#[[2]]]}&,
Transpose[{RandomArray[NormalDistribution[0, sigmar], n],
Table[Random[Real, 2[CapitalYAcute]], {n}]}]];{x1, y1} =
{Mean[First /@ t], Mean[Last /@ t]}rlist = Sqrt[(#[[1]] -
x1)^2 + (#[[2]] - y1)^2] & /@ t;r1 = Mean[rlist]HereÕs a
quadratic error function:Clear[a, b, r]error[a_, b_, r_, {x_,
y_}] = ((x - a)^2 + (y - b)^2 - r^2)^2error[a_, b_, r_, s:{{_,
_}..}] := Expand[Tr[(error[a, b, r, #1] & ) /@ s]]Set the
derivatives equal to zero, solve, select for positive real
rvalues, and choose the more reasonable alternative (the Last
solution,in the examples IÕve done):D[error[a, b, r, t], #] 
==
0 & /@ {a, b, r}Chop@NSolve[%, {a, b, r}];Select[%, Positive[r
/. #] &]{x2, y2, r2} = {a, b, r} /. Last@%Plot the data and
the three circles (Red for the defining circle, Bluefor
NigelÕs solution, and Gold for the least-squares
solution):<<Graphics`Colors`Show[ dataPlot, Graphics[ { Red,
Circle[{x0, y0}, r0], Blue, Circle[{x1, y1}, r1], Gold,
Circle[{x2, y2}, r2] }], ]I think the Gold circle will
usually be a better fit than the Blue one.Bobby-----Original
Message-----This is what I might do;Get in the statistics add
onIn[1]:=Needs[Statistics`NormalDistribution`]Create some test
values of (xi, yi)In[2]:=r = 3.3; x0 = 1.2; y0 = 3.4; sigmar =
.3; n = 50;In[3]:=t = Map[{x0 + (r + #[[1]])Sin[#[[2]]], y0 +
(r + #[[1]])Cos[#[[2]]]} &,
Transpose[{RandomArray[NormalDistribution[0, sigmar], n],
Table[Random[Real, 2[Pi]], {n}]}]];take a look at
themIn[4]:=Here I may be making unwaranted assumptions that
they are evenlydistributed about the circleFind x0 and y0
here identified as x1 and y1In[5]:={x1, y1} = {Mean[First /@
t], Mean[Last /@ t]}Out[5]={1.21852, 3.15013}using x1 and y1
convert the list to a list of radiiIn[6]:=rlist =
Sqrt[(#[[1]] - x1)^2 + (#[[2]] - y1)^2] & /@ t;Find the mean
and standard deviation of the
listIn[7]:=Mean[rlist]Out[7]=3.26131In[8]:=StandardDeviation[
rlist]Out[8]=0.444839
====
Sorry, not a direct answer to your
question.I attempt to minimize this problem by not using
global variables at all -except for one or two at the top of
whatever problem I am solving.That is, I use a few globals to
debug a given stretch of code,but then I wrap that code in a
Module, even if it is code ONLY USED ONCE.I save that
notebook, and reset my Mathematica session, and re-run
thenotebook.Of course, if I mistakenly leave out a variable
in my Module declaration,I would still run into the problem
you mention -so I have to occasionally look to see whether
there are unexpected globalvariables hanging around.A bit
laborious, but better than nothing.I, also, would like to
hear of any ways to keep out of trouble.In my case, what
would work would be a way to prohibit creation of newglobal
symbols, except through a special syntax - so that I could
avoidaccidentally creating globals.Ideas about how to do
this?Maybe there is something I could do using a Package
declaration -so that any symbol I would otherwise
accidentally declare global, ends updeclared in some Package
instead?-- Steve S. Shaw (a.k.a.
ToolmakerSteve)
====
Carlos,You could do something like
this...myReplace[rules_][expr_] := Module[{newrules}, expr /.
newrules]c = 1/2;1/2xx/23xc = 1/2;1/2xx/2x/2c =
1/2;1/2xx/23/2but it is hardly worth it. Much better is to
refrain from setting values forsimple symbols, or get into
the habit of always clearing them after usingthem.If you want
to distinguish between parameters and variables you could
definefunctions in the following manner...f[a,b][x]:= a Sin[x
+ b]and supply the parameter values when you need them. Or
you could set up datareplacement rulesThen manipulate your
equations and when you are finished substitute thedata. It is
almost always a mistake to put data into equations
andexpressions instead of substituting it at the end.I try to
never set values for single letter symbols, or any symbol that
Iexpect to manipulate algebraically. If want to save
intermediate results Iuse names like step1, step2 or expr1,
expr2 and other names that I amunlikely to ever use as a
general variable or parameter name.Following these simple
procedures will save you a lot of grief.David
Parkdjmp@earthlink.nethttp://home.earthlink.net/~djmp/Print[
exp//InputForm]; Print[exp//FullForm];3*Cos[psi] -
2*Sin[psi]Plus[Times[3,Cos[psi]],Times[-2,Sin[psi]]]the
scenes. OK, program mistake. I should have cleared c,part of
a long replacement list left over from legacy
code).Conclusion: a constant can be silently replaced by
another,warning. Here the intent is obvious. But when the
constantis hidden behind a symbol, this can be the source of
bugsdifficult to find, akin to self-modifying 
code.Is there a
way to automatically mark all constantsubexpressions as
protected against /. or //.? Sortof a automatic const
declaration. That would enhanceprogram safety.
====
 Does
anyone know if you can use Mathematica as a backend to
programming withany .NET compatiable language such as C# as
the front end? I would sooo liketo use Dot Net and would
perfer it over Java. But if IÕm forced to will useJava. But
if I had a choice I would like to use C# and if i donÕt I
would reallylike Wolfram to consider this as an advantageous
option, since a lot of peopleincluding, I, would really like
and appreciate this.RAyRAy =)
====
Andrzej'has done the hard
part in answering -note that the output can be improved using
Simplify:Sin[1 + x] + x*Sin[1 + x] /. Solve[b == 1+x,
x][[1]]//Simplifyb Sin[b]----- Original Message -----
====
Use
a direct change of variables:a == (1 + x) Sin[1 + x];a == (2
- b) Sin[2 - b]Bobby-----Original Message------Michael
Stern
====
Michael, a == b*Sin[b]or a == (Plus[1 + x])*Sin[1 +
x] /. Solve[b == 1 + x, x] {a==b Sin[b]} %[[1]] a==b
Sin[b]Allan---------------------Allan HayesMathematica
Training and ConsultingLeicester
UKwww.haystack.demon.co.ukhay@haystack.demon.co.ukVoice: +44
(0)116 271 4198
====
1. Mathematica can do algebraic
substitution in several ways, one of which isx^4 + x^2*y^2 +
x^8 + y^8 + 1 /. AlgebraicRules[ x^2 + y^2 == 1, x]3 - 5*y^2
+ 6*y^4 - 4*y^6 + 2*y^8Although AlgebraicRules is no longer
supported one can achieve the same effect (and more) with
GroebnerBasis and PolynomialReduce.2. It would be interesting
to know how optimazing compilers from the 1950s could do such
substitution, since in general it depends on GroebnerBasis
invented by Bruno Buchsberger in the 1970s.Andrzej
KozlowskiYokohama,
Japanhttp://www.mimuw.edu.pl/~akoz/http://
platon.c.u-tokyo.ac.jp/andrzej/
====
Workaround: IÕd rather
replace x instead of x+1, itÕs easier to 
find.Out[1]= b
Sin[b]Hope to help,Alfred
====
Workaround: IÕd rather replace x
instead of x+1, itÕs easier to find.Out[1]= b 
Sin[b]Hope to
help,Alfred
====
Hi,If I save some variable defs via DumpSave,
e.g.: DumpSave[interpsMM.mx, {iFunc, qFunc, uFunc, vvFunc,
vFunc}];then proceed to mess around with these defs within
the same session,and subsequently attempt to restore their
original defs (as of theDumpSave operation) by Get[]Õing 
them
back, e.g.: Get[interpsMM.mx];it turns out (apparently) that
Get[] will NOT overwrite the existing(modified) 
definitions.
Instead, one must first: Remove[iFunc, qFunc, uFunc, vvFunc,
vFunc]then invoke the Get[]. Is what IÕve depicted the 
actual
functioning of Mathematica or have Imisconstrued
something?
====
Carl, I had difficulty pasting the code you
suggested to Jan.I think I finally got it -here is the Cell
text from my .nb file,in case it is of use to anyone else
having trouble.(Might have more success doing cut/paste of
this form into Mathematica.)NOTE: I omitted
ImplicitSolve::usage, so that? ImplicitSolve would show the
internal code,not the usage instructions -in case something
has gone wrong with my
notebook.-------------------------Cell[BoxData[{
RowBox[{(Clear[ImplicitSolve]), n}], [IndentingNewLine],
RowBox[{(ImplicitSolve[eqn_List, rt_, {x_, min_, max_}, y0,
acc}, [IndentingNewLine]acc = (Cases[{opts}, x0 == {},
[IndentingNewLine]Message[ ImplicitSolve::badroot, x];
[IndentingNewLine]Return[], [IndentingNewLine]x0 =
x0[([1])][IndentingNewLine]]; n {y, y0} = Transpose[ rt] <
10^(((-acc)))]), [IndentingNewLine]Message[
ImplicitSolve::inaccurate]; [IndentingNewLine]y0 = Evaluate[
Sequence @@ Transpose[{y, y0}] ], opts ])[([All, 2])], n
Null, Message[ ImplicitSolve::incomplete ];
[IndentingNewLine] Return[][IndentingNewLine]];
[IndentingNewLine]NDSolve[ Flatten[{D[ x], nThread[((#1[x0] &
)) /@ y == y0]}], y, {x, min, max}, acc][IndentingNewLine]]),
n}], [IndentingNewLine], StyleBox[(ImplicitSolve::badroot =
<Supplied root is missingvalue
StyleBox[(ImplicitSolve::incomplete = <Supplied root
isincomplete StyleBox[(ImplicitSolve::inaccurate = <Supplied
root is -------------------------
====
To all:Apparently, from
the replies IÕve been getting, the problem I proposed is 
near
to intractable.Yes, I definitely agree: itÕs not 
that easy to
solve explicitly for the intersection of two high-degree
algebraic surfaces (and even more difficult for transcendental
ones).I have here two possible strategies for solving the
problem I proposed. My only problem is that I donÕt know how
to program them in Mathematica.Here they are:1) One
possibility might be a call to ContourPlot3D to plot the two
implicitly-defined surfaces, and then use a function that can
give a Line[] object that is the intersection of two
Polygon[] objects.(A bonus is that you will be able to put in
an option to the function which will alow the user to see the
two surfaces intersecting.). The only limiting factor is the
resolution of the two surfaces. My problem here is how to
write the Polygon[] intersection function.A sample invocation
for the Polygon[] intersection function might go like
this:In[1]:=
polyIntersection[{Polygon[{{1,1,0},{1,-1,0},{-1,-1,0},{-1,1,0
}}], Polygon[{{0, 2, 2}, {0, -2, 2}, {0, -2, -2}, {0, 2,
-2}}]}]Out[1]:= Line[{{0,-1,0},{0,1,0}}]Using that function,
we can map it on all the Polygon[] objects (and deleting
Line[] objects resulting from two touching Polygon[] s.);
resulting in a collection of lines forming the space curve.2)
There is a theorem that says that every curve (whether planar
or skew) is an envelope of its tangent lines. Using that, one
possibility might be to generate the tangent lines of the
implicitly defined space curve, then use a Line[] clipping
algorithm to shorten the Line[] s to the required length. I
have here a (rather messy looking) formula to compute the
tangent lines of a space curve at a point {x, y, z}. I tried
implementing it, and instead of getting a space curve, I
wound up with something that looked like a vector field.These
are my strategies.I suppose the function we are going to
write should also be able to detect special cases, e.g. if
one of the surfaces is a plane or a cylinder.My thanks to
everybody who gave their feedback. Jan M. (^_^)
====
IÕm trying
to implement automatic numbering of figure captions. This is
noproblem with the actual numbering eg. TextData[ {Fig. ,
CounterBox[ NumberedFigureCaption]}]], None}, {None, None}} I
get the figure number in the left hand cell margin okay...but
IÕd like thenumber to remain in the top left hand corner of
the cell.It currently ßoats in the middle left hand side of
the cell. IÕve tried including things like into the Cell box
that contains the CounterBox but that doesnÕt seem 
tohelp.Any
suggestions would be appreciated.thanksMike
====
[I was not
previously subscribed to this newsgroup, so I couldnÕt 
find a
way to attach to a thread more than a month old.Response to
Andrzej Kozlowski - OOP in Mathematica - 5 Nov 2002as well as
Orestis Vantzos - Re: OOP in Mathematica - 6 Nov
2002][Andrzej] -(one is the Object-Oriented Graph Theory in
Chapter III of GreyÕs MasteringMathematica),but all of them
can be programmed with no more effortusing the natural
Mathematica functional-pattern based style.Andrzej, that is
quite a claim.I do not wish to join a meaningless argument of
opinion.I would like to see some evidence.*** I would be very
happy to learn natural Mathematica ways to accomplishvarious
OOP objectives.If you can actually help me and others do
that, rather than just spoutingoff (like Mr. Jen does) about
how superior the Mathematica way is, then thatwould be a
great contribution.I will be presenting small snippets of
code from Java or Eiffel, anddiscussing how to accomplish the
result in Mathematica.I am well aware that doing so may
involve a complete re-arranging of how Ithink about
programming.If so, help me see it that
way.---------------Background:I have many years experience
with OOP in C++, Eiffel, and Java.I now have a practical
project that I would like to accomplish usingMathematica:I
wish to use Mathematica as a software modeling environment,
somewhatlike the software industry has standardized on as UML
(Unified ModelingLanguage).But rather than using UML, I would
like to use / help develop amathematically rigorous modelling
and simulation environment in Mathematica,which is intended to
ultimately spit out code in Java, Eiffel, C++, and/orC#.(I
wonÕt ignore UML where relevant - but UML has gotten rather
unwieldy. Iwish to build up from a few basic principles -
which we can discuss as thisproject unfolds.)The reasons for
spitting out code in those other languages:* performance.*
tight binding to existing large class libraries or other
existing code.* many companies ARE going to program in those
languages, rightly orwrongly - it would be a great benefit to
the industry to have amathematically valid way to develop
software that ultimately ends up inthose languages.I am
starting with Java, because of a 3D application which I am
developing.I am suggesting an Open Source OOP modelling and
simulation environment bedeveloped on Mathematica.I would not
presume to host such a development, until I understand
whatother projects have been done / are being contemplated,
by others.However, if no one else steps forward, I will take
that on. Presumably withcode at SourceForge.net.I have used
Mathematica previously on other projects, but am just
nowbeginning to explore how to represent OOP concepts within
it.I am about to look at the two code examples I see
references to. (RomanMaeder) (Hermann
Schmitt).-----------------------------------------------
Orestis - I see your post of 4 Nov 2002, OOP in Mathematica -
A concreteexample.With your delegation implementation of
Objects. You accomplish things I didnot know how to do in
Mathematica, so I will study closely.[Orestis] - I will be
happy to discuss issues like
Inheritance,Encapsulation,Dynamic Binding, etc. in future
posts.I very much wish to discuss those issues.Bertrand
MeyerÕs Design By Contract is central to my methodology, so
Iwish to discuss how to implement that as well.-- Steve S.
Shaw (a.k.a. ToolmakerSteve)
====
More fun with OOP.Working
with Orestis Vantzos'delegating Object idea (upvalues).This
continues from the example he gave, which ended
with:Object.new[ obj1
]obj1@myField[]=OOP!;--------------------Now some Mathematica
as I try his idea out.--------------------(* SSS- removed the
Print from Orestis version, as part of changes I ammaking for
a future example. *)Object@myMethod[]:=$self.myField[];(* SSS-
create another object, and give it a field. *)Object.new[ obj2
]obj2@myField[]=TA DA!;(* SSS- Now, pass an object as a
parameter. First, by value. *)doit[ ob_Symbol
]:=ob.myMethod[];doit[ obj1 ]//Print;doit[ obj2
]//Print;--------------------OOP!TA
DA!--------------------Okay, IÕm convinced that we have
objects that can be passed around, andacted on.Next, I will
try this on both R. MaederÕs and H. 
SchillerÕs
OOimplementations in Mathematica.Then, I will explore/ask how
to match functionality that is found in Java,Eiffel, or
C++.IMO (in my opinion), of those three, only Eiffel has a
mathematically soundfoundation(as developed in B. Meyer,
Object-Oriented Software Construction, SecondEdition,
1997).Eiffel has specific features that I plan to emulate in
Java:* Design By Contract (pre-conditions, post-conditions,
class invariants);* Multiple Inheritance (Java has for
Interfaces, but not class-to-class);* Constrained Genericity
(a refinement of Templates).I am also interested in OO
feature(s) that even Eiffel lacks:* Multiple-dispatch of
methods (multimethods), as described
in:www.cs.washington.edu/research/projects/cecil/www/Papers/
oopsla00.html;* perhaps other features found in Cecil, as
described at that URL.I will begin by focusing one at a time
on each desired OO feature,starting with the most basic OO
features -already, some have been demonstrated in code by
others here.To keep this understandable - I will explain each
feature as I need it,showing small concrete examples of what I
seek.I do not claim to be expert on these features, but I will
do my best.I will give small code examples in Eiffel, Java, or
Cecil as appropriate,and refer to books and to web URLÕs for
theoretical background.I will attempt to re-create these
examples in Mathematica, and ask foreveryoneÕs help in
improving the Mathematica solutions.I especially need
insights into using Mathematica features that Orestismentions
-... one can define methods with conditions, predicates,
patterns...!When complete, we should have learned together
how to handle in Mathematicaany of the features in Eiffel,
Java, or C++,as well as some features that none of those
languages handle well.- - - - -My plan is to plod along,
raising small points one by one.I hope that everyone will not
be shy about suggesting solutions andalternatives.And in
raising other ideas about object-oriented programming.On the
other hand, there appear to be one or two folks on this list
whoshould just ignore this whole thing - IÕm not interested
in anyoneÕsself-important opinion as to why this is a waste
of time.Billions of dollars of software written poorly every
year -I believe software practices could be greatly improved
by building bridgesbetween a mathematically sound environment
(Mathematica), and the existingcomputer languages that
programmers will end up using, for reasons thatthere is no
point in discussing here.Existing linkages from Mathematica
to Java and to C++ are a start.I wish to go much further.I
wish to write and debug in Mathematica, then automatically
translate intoother languages - to connect efficiently to
large bodies of code thatalready exist in those languages.A
large topic. LetÕs tackle in small 
pieces.LetÕs help each
other learn more about Mathematica, and aboutstate-of-the-art
ideas in object-oriented programming. *smile*-- Steve S. Shaw
(a.k.a. ToolmakerSteve)
====
Jens Kuska and others including, I
hope, myself have shown over the years quite a few people how
to accomplish various tasks in Mathematica without any
recourse to object oriented programming, so I donÕt see much
need to prove anything in this respect. Just look through the
past archives, and you will see that surprisingly few
questions posted to this list, (some of which are pretty
difficult), remain unanswered. But I also have to add that I
personally like to answer questions that interest me. I 
canÕt
promise that this will be the case with to what you want to
do. I am a mathematician and not particularly keen to devote
any of my time merely to proving a point. However, if all you
want to see how to do graph theory in the natural Mathematica
style I certainly can oblige: in fact you donÕt even need 
me.
Just look at the Combinatorica package, then compare it with
GreyÕs Object oriented Graph Theory and you will yourself
realize why I donÕt think OOP brings anything useful to
Mathematica, at least for the sort of purposes that interest
me.Andrzej KozlowskiYokohama,
Japanhttp://www.mimuw.edu.pl/~akoz/http://
platon.c.u-tokyo.ac.jp/andrzej/
====
Andrzej,Okay. I respect
your viewpoint now that you put it that way.You had
previously made the sweeping statement -that OOP doesnÕt
bring anything useful to Mathematica -WITHOUT the qualifier
you now give above.I am new to this list - so I did not have
a sense of history; of what yourinterests are.The value I see
in OOP is in BUILDING and CHANGING complex systems orsoftware
machines.Systems that are beyond what a single human mind can
comprehend all atonce. Therefore, many techniques have been
developed to make such a taskpractical.Systems that factor
into a myriad of details that must be dealt with in afraction
of a second on an inexpensive PC. Therefore,
optimizationtechniques must be used.For example, Mathematica
itself is such a system. If you were StephenWolfram, and you
had Mathematica already existing, how would you use it
tocreate a clone of itself on a new computer, building upon
only theinstructions of that new computer?This would be far
more than a mathematics exercise.Another such system is Java,
including its virtual machine, and itsextensive class
libraries.Another system is the microprocessor chips that
make it possible for us touse Mathematica and other
tools.Just like Stephen Wolfram wanted everyone to have the
full power ofmathematics at their fingertips,I am one of many
who would like everyone to have the full power
ofhigh-performance, modifiable software machines at their
fingertips.- - - - -I have come to Mathematica in hopes that
its mathematically solid core willprovide better ways to
develop such software machines.I want everyone to be able to
work with such machines.And I believe that many users of
Mathematica would benefit from a framework/ package that
embodied hard-won principles of construction from
othersoftware environments and other engineering
disciplines.I do not wish to impose outside ideas, in
situations where Mathematicaalready has superior approaches.I
want to find a small set of powerful ideas that can be shown 
to
buildunderstandable and modifiable high-performance 
systems.The
only way I know to do this, is to suggest the ideas that I am
aware offrom other environments, to show WHAT IS USEFUL about
those ideas, and thento attempt to accomplish similar goals in
Mathematica.I only ask that experienced Mathematica hands not
be arrogant about thisattempt.If there is a more natural
Mathematica way, then please enlighten me.But gently - not
scoffing at the very attempt.I will do my best to incorporate
that enlightenment into a package that manyMathematica users
can benefit from.In exchange for help from others, I am
offering that the package be OpenSource, so that the whole
community benefits.This is part of the path that I am on in my
life.-- Steve S. Shaw (ToolmakerSteve)
====
A series of OOP
experiments in Mathematica.----- Goals and References ------
- - - -Goals:1. explore Object-Oriented Programming
techniques in Mathematica.2. find alternate ways to accomplish
those ends.3. measure performance in Mathematica.4. Develop an
Open Source Mathematica Package, so that these techniques
arereadily available to any interested Mathematica user.5.
Explore how to translate from the Mathematica form to {Java,
Eiffel, C++,C#} -so that Mathematica can be used as a
development tool by programmers inthose other languages.- - -
- -feel represents best practices, primarily in the software
industry. Ihave omitted other equally valuable books, that
are not relevant here. Ihave undoubtedly also omitted books
that would have done as well as these,simply by not being
personally familiar with them.I will be referring to these
throughout these experiments,for anyone who wants more
background information.(Though I will attempt to answer any
specific questions, by referring to thebooks myself.)-----
Books on Software: ------- Languages --* [Chan-98] Chan, Lee,
and Kramer, The Java Class Libraries, Second Edition,Vol. 1 &
2 & Supplement for Java 2 (v1.2), 1998-99.Wonderful little
examples for every little feature of the Java libraries.*
[Harvey-99] Harvey and Wright, Simply Scheme - Introducing
ComputerScience, Second Edition, 1999. Scheme - a
widely-used, streamlined Lisp. Good place to start onsoftware
theory.* [Meyer-97] Meyer, Bertrand, Object-Oriented Software
Construction, SecondEdition, 1997. Inventor of Eiffel
language develops & justifies a set of OO features fromthe
ground up. A bit abstract, not for beginners, but awesome.*
[Williams-02] Williams, Mickey, Microsoft Visual C#.NET,
2002. Microsoft Press book detailing C# + .NET.-- Mathematica
--* [Gray-98] Gray, John, Mastering Mathematica: Programming
Methods andApplications, 1998.* [Maeder-00] Maeder, Roman,
Computer Science with Mathematica, 2000.* [Wolfram-99]
Wolfram, Stephen, The Mathematica Book, Fourth Edition,
1999.-- OO research --* [Abelson-96] Abelson & Sussman,
Structure and Interpretation of ComputerPrograms. An
alternative to Friedman-97. For my purposes, most important
iscoverage of concurrency and time. [SEE NOTE #1 AT END].*
[Friedman-97] Friedman, Wand, and Haynes, Essentials of
ProgrammingLanguages, 1997. functional (no-side-effect)
expressions. Lambda calculus. Read afterHarvey-99.*
[Gamma-95] Gamma, Helm, Johnson, and Vlissides, Design
Patterns, Elementsof Reusable Object-Oriented Software, 1995.
The seminal Gang of 4 book on Design Patterns that a plethora
of booksand papers refer to.* [Grand-02] Grand, Mark,
Patterns in Java, Volumes 1, 2, & 3, SecondEdition, 2002.
Brings together Java, UML, and Design Patterns.*
[Jezequel-00] Jezequel, Train, and Mingins, Design Patterns
and Contracts,2000. After youÕve read Gamma-95, read this to
find out how to make RELIABLEdesign patterns, using
contracts.* [Selic-94] Selic, Garth, and Ward, Real-Time
Object-Oriented Modeling,1994. An excellent model of
simultaneous, communicating, live actorsrepresenting both
hardware and software.----- Other Technical Books: -----*
[Gajski-94] Gajski, Vahid, Narayan, and Gong, Specification
and Design ofEmbedded Systems, 1994. States a set of
requirements for designing or simulating an embedded
system(real-time hardware). Summarizes many techniques,
w.r.t. thoserequirements, including StateCharts and VHDL -
finding specific shortcomingsof each. Introduces 
SpecCharts as
an extension to VHDL - shows howrequirements are met.*
[Jensen-97] Jensen, Kurt, Coloured Petri Nets, Volume 1,
Second Edition,1997. CPNÕs are a mathematically rigorous
representation of system behaviour,used in formal analysis
and proofs. I hope to replace UMLÕs interactiondiagrams with
a rigorous solution inspired by CPNÕs.----- Web URLs:
-----(more later - I havenÕt systematically collected these 
-
do Google search onany technical term).-- Eiffel --*
smarteiffel.loria.fr - the free GNU Eiffel compiler.*
www.eiffel.com - Bertrand MeyerÕs implementation of 
Eiffel.--
Java --* developer.java.sun.com/developer/infodocs/ - Java
docs and tutorials andlinks.-- OO research --*
www.cs.washington.edu/research/projects/cecil/cecil/www/
cecil.html -Cecil - a superb research implementation of OO
principles.-- Standards --* www.omg.org/uml/ - Unified
Modeling Language - software industry standardfor designing
systems.- - - - -NOTE #1:Re Abelson-96.pp. 297-357. pp.354-7
A functional-programming view of time is theclosest published
work I have found to ideas I am working on, to replace theVon
Neumann model of programming with a stateless
(side-effect-free;immutable) one - yet retain the
high-performance of traditionalregister-and-memory
computers.The authors brießy describe such a stateless
representation. Verybrießy - the passage may seem
insignificant or trivial to most readers. Aucontraire, it is
the heart of a reliable model of programming - somethingthat
cannot be fully achieved in the traditional Von Neumann
model. Thoughcontracts are an acceptable substitute in the
interim - forcing logicalinconsistencies to surface at
run-time.To achieve the high performance, use principles from
Gajski-94, Jensen-97,Selic-94, plus modern compiler
optimization techniques (which I donÕt havereferences on -
falls outside my focus).Given an extensive literature in
no-side-effect functional programming, whydonÕt I stick to
that rather than OO?1. Performance. I am determined to have
my cake and eat it too - the purefunctions researchers have
yet to deliver full performance.2. Understandability. Except
to mathematicians, pure-functional and lambdaparadigms simply
donÕt come naturally, in many important uses. I seek
poweraccessible to all, not just to the relative few whose
minds naturally workthat way.-- Steve S. Shaw (a.k.a.
ToolmakerSteve)
====
*in Mathematica*, that I could not do
equally without it. I stand by this if someone produced an
useful example that showed otherwise. That was in an earlier
posting in the same thread, but even from the posting you
quoted it is cllear itÕs up to the fans of OOP to produce
examples that show that OOP can be usefully implemented in
Mathematica, not for me to produce examples to show that it
canÕt.The rest of your message is for me just too general to
deal with. I agree that OOP is useful for dealing with
complex structures in fact I message. I do think also that
Mathematica was designed to deal with concrete problems of
general mathematical nature and to be as ßexible as possible.
It is not intended, for example, as a tool for simulating an
airplane. However, one can use it to solve many mathematical
problems that would be useful in such a simulation.
Mathematica was never intended to fully replace Java or C,
otherwise there would be not much sense in MathLink and Java
Link.I guess thatÕs all I wish to say on this matter. I
expect others who have more interest in such issues will say
make more useful comments. But as my final (I hope) comment on
this matter let me re-state that I would be very happy to see
someone produce a useful OOP extension to Mathematica and
someone do something non-trivial with it. But I am sure it
will not be me who will do so.Andrzej KozlowskiAndrzej
KozlowskiYokohama,
Japanhttp://www.mimuw.edu.pl/~akoz/http://
platon.c.u-tokyo.ac.jp/andrzej/
====
Andrzej,I respect that.I
apologize for accusing you of saying something that you did
not say.What you said was indeed very clear -- to YOURSELF.
And perhaps to otherswho are more familiar with your posts.
Obviously not clear to me. To me,you appeared to be making a
deliberately inßammatory statement. That iswhy I responded
the way I did.A shame to get off on the wrong foot.Being new
here, I am willing to say that the fault is all mine, so that
wecan get past this, and do useful work.I would love to bounce
ideas off you - and see what solutions you come upwith.So, I
hope to come up with problems that are worth wrestling with.
*smile*- - - - -I like your perspective.Sure, we can put OOP
features into Mathematica - but what is the BENEFIT?So I have
decided to change my approach. Before diving into
specificfeatures of OOP - and into the whole framework of how
to develop complexsoftware that was built in the 90Õs on top
of OOP - I think to do thefollowing.Go back to the basic
research in OOP.Take small little examples.Show how various
OO thinkers recommend doing them.Show little code snippets in
OO languages.Attempt to do them in Mathematica.I welcome all
suggestions as to alternate Mathematica approaches.Coming
soon - one of the classic programming examples -The
Stack.Starting with a formal mathematical specification 
!!IÕll
show how to implement that specification using 
OOP.IÕll
challenge you to show me how to do that in a more natural
Mathematicaway. *smile*-- Steve S. Shaw
(ToolmakerSteve)
====
For appearance reasons I usually place
all my Plot and ListPlot options in alist eg.When I plot a
list everything is fine:ListPlot[list, optionA]but when I use
options in Plot I get an error message unless I wrap
Evaluatearound the options.For examplePlot[x^2,{x,0,5},
optionB]Plot[x^2,{x,0,5}, Evaluate[optionB]]??? why is this
so????Why must I wrap Evaluate around my options in
Plot?thanksMikeps. This is with version 4.0.2 on a G4 power
Mac.
====
IÕm confused here. If I try the following commandI
get a nice 3D plot of a surface that has dimples where the
complex zeros are.BUTIf I try the
following:f[x_,y_]:=Abs[1+(x+Iy)^3]Mathematica refuses to
plot it at all giving me at least half a dozed
incomprehensible error messages. I imagine IÕm using some
sort of wrong convention but damned if I can figure it 
out.IÕm
using Mathematica 3.0 on a Mac clone (PowerTower Pro with G3
accelerator) running OS 8.6.IÕd be most grateful for any
help.thanks,Warrne Rogers
====
Dear newsgroup members,perhaps
this is a very simple question.Imagine you execute the
following commandwithin a notebook with chosen background as
RGBColor[0,0,1] via option inspectornotebook optionsdisplay
options (scope notebook).The result is a plot where the
rectangular space of the plot label remains white.How can I
control this (strange) behavior? I thought that automatically
the color of this area should be the same as the background
color of the plot controlled byFrank
====
I wanted to just
display a tetrahedron scaled smaller and translatedalong the
z-axis like the example on p.517 of the S.Wolfram book(V.4).
After I figured out that the example used a cuboid and
theconstructor for the tetrahedron would not work the same
way, I deviseda way to accomplish this. However, I have seen
so many exercises thatcan be accomplished more easily when I
gain more knowledge.I figured out that the tetrahedron is just
a list of polygons, whichare just a list of triples. So, here
goes:<<Graphics`Polyhedra`t0=Tetrahedron[]f0=Function[x,0.2*x
] (* make it 20% as big *)t1=Map[f0,t0,{4}] (* go down to
level 4 *)f1=Function[x,{x[[1]], x[[2]], x[[3]]+0.1}] (* move
it up by 0.1 *)t2=Map[f1, f2, {3}] (*this time it should work
on the points *)Show[Graphics3D[{t2}]] Is there some easier
way to translate/scale a polyhedron (or polygon)?Note: Of
course, I am happy that this can be accomplished at all,using
these weird mapings! :-))
====
Frank,It is difficult to
understand why you donÕt just use Part in the 
firstplace. In
any case, you canÕt precompute the rhs of your function
becauseMathematica requires an Integer instead of a symbol
for a partspecification. If you want a more convenient form
for Part you could dosomething like this...tab = Table[n, {n,
1, 10}];myLookup[i_Integer][table_] := Part[table, i]tab //
myLookup[3]3David
Parkdjmp@earthlink.nethttp://home.earthlink.net/~djmp/the
error message: Part::pspec: Part specification i is neither an
integer nor alistof integers.I suppose IÕll simply ignore 
this
message, but is there some bettermeans of defining a table
lookup function?
====
What about this approach? Define a table
(mytable=Table[n, {n, 1, 10}]).Then you define the function
like
thismyFunc[tablein_,lookupposition_]:=tablein[[lookupposition
]]. This, however,is equivalent to
mytable[[lookupposition]].-----Original Message-----This
works, but nonetheless, upon defining the function,
Mathematica returnsthe error message: Part::pspec: Part
specification i is neither an integer nor alistof integers.I
suppose IÕll simply ignore this message, but is there some
bettermeans of defining a table lookup
function?
====
myFunc[i_Integer]:=myFunc[i]=Table[n,{n,1,10}][[
i]]better yetmyFunc[i_?(1<=#<=10 &&
IntegerQ[#]&)]:=myFunc[i]=Table[n,{n,1,10}][[i]]or
evenTable[myFunc[n]=n,{n,1,10}]The last is the most efficient
since the table is only created once.Ssezi
====
Hi
experts,circle (x-x0)^2 + (y-y0)^2 = r^2 to these points. I
need r and sigma_r.It could be helpful to get x0,y0 also, but
it is not nessecary.I found a algorythm for another system
(LeastSquareFit) but not for Mathematica 4.Who can
help?Dieter--Dieter Palmedl7udp
====
there an updated
version.LogPlot]{HoldFirst} I do not understand why this is
insufficient to hold off the evaluation until q gets a value.
I suspect that it is something to do with the complexity of
LogPlotÕs calls to scaledplot etc.value is substituted for 
q.
If this is not true in version 4.0, then youunfamiliar with
Unevaluated. One would expect it to do the trick but it
results. TB I am reasonably certain the the incorrect results
are caused by premature evaluation since I have rebuilt the
function outside Would I be right in presuming that 4.2 has
this problem fixed in which case it would be nice to be able
to get hold of the 4.2 version of ContinuousDistributions.m
My other possibility is to call my version that I will need
to Set the context to
Statistics`ContinuousDistributions`Private`
Clear[Quantile[NoncentralChiSquareDistribution]] Reprogram
with the q_?NumericQ in place.-- Nigel PS sorry if this is a
resend I am having trouble with my news browser
====
N[] on
your final output to the desired precision will do what you
want Ithink. It works on arrays too, and is quite fast.
--Urijah Kaplan
====
I want to solve the following equation, A1
x^2 yÕÕ[x]+A2 x^2 yÕ[x]^2+A3 x 
y y[x]=A4 x^3 y^4+A5 x^2
y^3w/BCs:yÕ[0]=0 and y[a]=A6Could someone can 
find a way out
for this?
====
Diana,To move the cursor out of a box structure,
such as the square root sign, useeither Ctrl-Space or the
right cursor key.Concerning your postscript: Do we really
know that Integers are theprimordial entities, rather than
points or processes or relations orsomething else?David
Parkdjmp@earthlink.nethttp://home.earthlink.net/~djmp/all my
numbers.Can someone
help?Diana--
====
=============================================

====
God made the integers, all else is the work of man.L.
Kronecker, Jahresber. DMV 2, S.
19.
====
wasofDiana,Control+Space will get you out of the
square root.Allan---------------------Allan HayesMathematica
Training and ConsultingLeicester
UKwww.haystack.demon.co.ukhay@haystack.demon.co.ukVoice: +44
(0)116 271 4198
====
I want to ask if anyone has tried to write
a function that can plot, say, a space curve defined as the
intersection of the surfaces x^2 +y^2 +z^2 == 1 and z ==
Sin[x y].If not, how can I do it? IÕd appreciate any 
feedback
on this. Jan M. (~_~)
====
Steve,Do you know if it would work
for the table generated with:<< DiscreteMath`Combinatorica`A5
= AlternatingGroup[5]mult[x_?PermutationQ, y_?PermutationQ] :=
Permute[x, y]MultiplicationTable[A5, mult] //
TableFormDianaexample,
====
Matthias,I am not able to reproduce
your results for the table generated with thefollowing code:<<
DiscreteMath`Combinatorica`A5 =
AlternatingGroup[5]mult[x_?PermutationQ, y_?PermutationQ] :=
Permute[x, y]MultiplicationTable[A5, mult] // TableFormI am
wanting to get this table to print out in Excel without
formatting.Dianashowsprcedureand24,35,46,57,18,44,55,33,20,59,
31,48,33,20,58,42,35,48,22,59,
====
Matthias,I am not able to
reproduce your results for the table generated with
thefollowing code:<< DiscreteMath`Combinatorica`A5 =
AlternatingGroup[5]mult[x_?PermutationQ, y_?PermutationQ] :=
Permute[x, y]MultiplicationTable[A5, mult] // TableFormI am
wanting to get this table to print out in Excel without
formatting.Dianashowsprcedureand24,35,46,57,18,44,55,33,20,59,
31,48,33,20,58,42,35,48,22,59,
====
Steve,Do you know if it
would work for the table generated with:<<
DiscreteMath`Combinatorica`A5 =
AlternatingGroup[5]mult[x_?PermutationQ, y_?PermutationQ] :=
Permute[x, y]MultiplicationTable[A5, mult] //
TableFormDianaexample,
====
I want to slove this problem but
X(k) and Y(k) are differentdimension vectors.k = argmax |
X(k) - Y(k) |I thought of simply doing argmax |X(k)| - |Y(k)|
but that will giveme a different result...thanks in
advance,David. The hunger for knowledge only grows as one
knows more.....David R. Hardoon
David.R.Hardoon@cs.rhul.ac.ukDept of Computer Science, Royal
Holloway, University of LondonMobile: +44 7967 634954 www:
http://g4.cs.rhul.ac.uk
====
>-----Original Message----->Sent:
Thursday, November 14, 2002 12:12 PM>To:
mathgroup@smc.vnet.net>My question about Complement and
UnsortedComplement.>Function UnsortedComplement [list, listi]
working more slowly then>function Complement>[list, listi]
because deletes elements listi behind many >passes, whereas>
Complement [list,>listi] it makes for one pass.>What kind of
procedure I can use to write SssssComplement >[list, list1]
>for maintenance of>removal elements list1 from list without
sorting, but for one pass?>The specified lists already are
sorted before their processing >by function
>SssssComplement>[list, list1] .>It is necessary for
acceleration of accounts.>Example for check of correctness of
work of required function:>SssssComplement [{1,3,5,7,10}, {3,
7,10}] should give>{1,5}.>But>SssssComplement [{1,3,5,7,10},
{7,3,10}] should give>{1,3,5}, as for one pass the number 3
will not leave.>Vasil.Vasil,in honour of Carl WollÕs
unforgetable
OrderedUnion:http://forums.wolfram.com/mathgroup/archive/1999
/Jul/msg00085.htmlOrderedComplement[l_List,ll___List]:=
Block[{i,Sequence}, i[n_]:=n; Scan[(i[#]=Sequence[])&,
Union[ll]]; i/@l]In[2]:=
OrderedComplement[{5,7,1,3,10},{10,7,3}]Out[2]= {5,1}In[3]:=
OrderedComplement[{5,7,1,3,10},{10},{7,3}]Out[3]=
{5,1}In[4]:= 0rderedComplement[{5,7,1,3,10}]Out[4]=
{5,7,1,3,10}(Ordered here means, the existing order is not
destroyed, rather thanre-ordered.)Here also a more
straightforward alternative solution:In[12]:=
UnsortedComplement[l_List, ll___List] := l[[
Sort[Flatten[Position[l, #] & /@ Complement[l, ll]]]
]]In[13]:= UnsortedComplement[{5, 7, 1, 3, 10}, {10, 7,
3}]Out[13]= {5, 1}In[14]:= UnsortedComplement[{5, 7, 1, 3,
10}, {10}, {7, 3}]Out[14]= {5, 1}In[15]:=
UnsortedComplement[{5, 7, 1, 3, 10}]Out[15]= {5, 7, 1, 3,
10}This may be advantageous when the complement is small (but
the lists werelarge). I didnÕt test however.--Hartmut
WolfReply-To: kuska@informatik.uni-leipzig.de
====
in general
you can do everything withMathematica that you can do with
any otherprogramming language.Can you more specific ? I know
what a hemispherical viewist but I have no idea what a
rasterization of a vectoris.And what is the simulation of 3
million cylindersSay you use 18 x 2 polygons for your
cylinder.Probably you will wait forever until MathematicaÕs
PostScript renderer has drawn 60 * 10^6 polygons.You can try
MathGL3d
http://phong.informatik.uni-leipzig.de/~kuska/mathgl3dv3/and
a good graphics card GeForce 3/4or ATI Radeon to render 60
Million polygons but you haveprobably to wait 30-45 seconds.
Jens> Dear all,> as an absolute beginner in Mathematica, I
would like to visualize in 3-D> hemispherical views by means
of projection (actually rasterization of a> vector). Does
anybody know if this is possible?> Moreover I was wondering
what would be the calculating time for the> simulation of 3
million cylinders in the new version of Mathematica? can>
anybody check this for me, as I still have an older version.>
Inge
====
Dear Jia,the Import function of Mathematica is very
slow. If all entries in your Matrix have the same type, you
can use ReadList[file,Table[Number,{750}]]. This is may be
hundred times faster.If your entries have different types,
useReadList[file,Table[Word,{750}]].Then all entries are read
as strings. You can convert the Strings containing numbers
then with ToExpression.Applying ToExpression for the
non-numeric rows orcolums will also be much faster (probably
by a factor of 100). Johannes> I currently have such a
problem in Mathematica: > I have a matrix of size 750*750. It
is in a file and I will import the> file to 
Mathematica using
the command: g = Import [matrix.dat,> Table].> However, it
took me over 2 hours to import and display the numbers in>
the notebook. But the transpose and reverse operations to the
matrix> are really fast: 4-5 seconds. I translated the matrix
into a graph and> when I was going to export it, the same
problem happened. It slowed> down again.> Does anybody know
what should I do to avoid the big overhead?> Jia>
<><><><><><><><><><><><>Johannes LudsteckEconomics
DepartmentUniversity of RegensburgUniversitaetsstrasse
3193053 Regensburg
====
> Here what I am trying to do:>
a={1,2,3};> b={4,5,6};>
c={{a[[1]],b[[1]]},{a[[2]],b[[2]]},{a[[3]],b[[3]]}}>
{{1,4},{2,5},{3,6}}> I tried: Do[{{a[[i]],b[[i]]}},{i,3}] And
it is not working.You have already received some suggestions.
Here are two other ways that could be used: Table[{a[[i]],
b[[i]]}, {i, Length[a]}] {a[[#]], b[[#]]} & /@
Range[Length[a]]Ciao,Martin
====
> [...]> a={1,2,3};>
b={4,5,6};>
c={{a[[1]],b[[1]]},{a[[2]],b[[2]]},{a[[3]],b[[3]]}}> [...]> I
tried: Do[{{a[[i]],b[[i]]}},{i,3}] And it is not working.>
Since my first posting I found that Transpose[{a,b}] will do
it.> But I would like to know why the Do loop is not doing it
!> RobertI think your expectation about the behaviour of 
ŌDoÕ
is Unless an explicit Return is used, the value returned by
Do is Null.What you propably wanted to use is
ŌTableÕ.Rainer
====
>-----Original Message----->Sent: Friday,
November 15, 2002 9:02 AM>To: ŌMozalev VasilÕ;
mathgroup@smc.vnet.net>>>-----Original Message----->>Sent:
Thursday, November 14, 2002 12:12 PM>>To:
mathgroup@smc.vnet.net>>My question about Complement and
UnsortedComplement.>>Function UnsortedComplement [list,
listi] working more slowly then>>function Complement>>[list,
listi] because deletes elements listi behind many >>passes,
whereas>> Complement [list,>>listi] it makes for one
pass.>>What kind of procedure I can use to write
SssssComplement >>[list, list1] >>for maintenance of>>removal
elements list1 from list without sorting, but for >one
pass?>>The specified lists already are sorted before their
processing >>by function >>SssssComplement>>[list, list1]
.>>It is necessary for acceleration of accounts.>>Example for
check of correctness of work of required
function:>>SssssComplement [{1,3,5,7,10}, {3, 7,10}] should
give>>{1,5}.>>But>>SssssComplement [{1,3,5,7,10}, {7,3,10}]
should give>>{1,3,5}, as for one pass the number 3 will not
leave.>>Vasil.>>>>>>Vasil,>>in honour of Carl WollÕs
unforgetable
OrderedUnion:>http://forums.wolfram.com/mathgroup/archive/
1999/Jul/msg00085.html>OrderedComplement[l_List,ll___List]:=>
Block[{i,Sequence},> i[n_]:=n;> Scan[(i[#]=Sequence[])&,
Union[ll]];> i/@l]>In[2]:=
OrderedComplement[{5,7,1,3,10},{10,7,3}]>Out[2]=
{5,1}>>In[3]:=
OrderedComplement[{5,7,1,3,10},{10},{7,3}]>Out[3]=
{5,1}>>In[4]:= 0rderedComplement[{5,7,1,3,10}]>Out[4]=
{5,7,1,3,10}>>(Ordered here means, the existing order is not
destroyed, >rather than re-ordered.)>Here also a more
straightforward alternative solution:>>In[12]:=
UnsortedComplement[l_List, ll___List] := > l[[
Sort[Flatten[Position[l, #] & /@ Complement[l, ll]]]
]]>>In[13]:= UnsortedComplement[{5, 7, 1, 3, 10}, {10, 7,
3}]>Out[13]= {5, 1}>>In[14]:= UnsortedComplement[{5, 7, 1, 3,
10}, {10}, {7, 3}]>Out[14]= {5, 1}>>In[15]:=
UnsortedComplement[{5, 7, 1, 3, 10}]>Out[15]= {5, 7, 1, 3,
10}>>This may be advantageous when the complement is small
(but the >lists were large). I didnÕt test
however.>>-->Hartmut Wolf>Essentially UnsortedComplement is a
quadratic algorithm, such its range ofapplicability is rather
narrow. Here now is an algorithm which like (the nowobsolete)
UnsortedComplement above uses built-in Complement and
thenrestores order, but now is of linear Order (for the
reconstruction phase);of course Complement -- though very
fast -- is O[n log n] if n is the sizeof the
input.UnsortedComplement[l_List, ll___List] := Block[{pos},
pos[_] := {}; MapIndexed[(pos[#1] = {pos[#1], #2}) &, l];
l[[Sort[Flatten[pos /@ Complement[l, ll]]] ]]
]Timings:In[2]:=x = Table[Random[Integer, 100000], {50000}];y
= Take[x, 40000];In[4]:= z0 = Complement[x, y]; //
TimingOut[4]= {0.481 Second, Null}In[6]:= z2 =
OrderedComplement[x, y]; // TimingOut[6]= {11.236 Second,
Null}In[8]:= z0 == Union[z2]Out[8]= TrueButIn[9]:=
Length[z0]Out[9]= 6336In[10]:= Length[z2]Out[10]=
6661In[26]:= z3 = UnsortedComplement[x, y]; // TimingOut[26]=
{19.729 Second, Null}In[27]:= z2 == z3Out[27]= True--Hartmut
Wolf
====
Something which is probably obvivous to the casual
observer but not me ... Can someone tell me how to get a
numerical value for from a NormalDistribution[0,1] Random
only returns a random value between 0 & 1
====
> Something
which is probably obvivous to the casual observer > but not
me ... > Can someone tell me how to get a numerical value for
> from a NormalDistribution[0,1] > Random only returns a
random value between 0 & 1> This loads the package which
defines continuous statistical distributions.In[1]:=
<<Statistics`ContinuousDistributions`This represents a normal
distribution with mean zero and unit variance. In[2]:= ndist =
NormalDistribution[0, 1]Out[2]= NormalDistribution[0,1]Here is
a symbolic result for the cumulative distribution function of
the normal distribution. In[3]:= CDF[ndist, x]Out[3]= !(1/2
((1 + Erf[x/@2])))This gives the value of x at which the cdf
of the normal distribution reaches the value 0.9. In[4]:=
Quantile[ndist, 0.9] // NOut[4]= 1.28155Here is a list of five
normal[Hyphen]distributed pseudorandom numbers. In[5]:= Table[
Random[ndist], {5} ]Out[5]=
{-1.63994,0.987641,-0.475946,-0.598517,-1.04913}Is this what
youÕre looking for?HTHMarc-- Marc Heusserremove the obvious
CHEERS and MERCIAL... from the reply address
====
Adam,> In my
ancient FORTRAN computer codes I got in the habit of>
representing some subscripts and spaces with the underline
character> _.The are several characters that resemble the
underscore and may appearwithin a name, among them
[UnderBracket] and [HorizontalLine]. These bothhave shortcuts
but, if you are going to enter a lot of these, you might
wantto train the front end to accept a character sequence
that is easier totype. (See InputAutoReplacements in the
Options Inspector.)Would you accept a dash instead? It has a
relatively quick standard shortcut(if you donÕt reaching for
the ESC all the time!) and, on my Mac at least, avery fast
key sequence: Option-hyphen (aka Alt-hyphen).Tom Burton
====
>
1>> Out[2]= Sqrt[Pi] PolyGamma[0, -]>> 2>> Out[3]= Sqrt[Pi]
(-EulerGamma - Log[4])>> Certainly it is simpler than
Out[2].> Not according to MatheamticaÕs default meaning of
simpler:Indeed. Perhaps I was a bit hasty in my judgment.
Having read thehelp from FullSimplify in greater detail, I
see how I can coaxMathematica to do what I want.-Nevin
====
> I
am a bit perplexed by the following behavior of Mathematica:>>
( 6:22PM) bombay[~]% math> Copyright 1988-2002 Wolfram
Research, Inc.> -- Motif graphics initialized -->> In[1]:=
GammaÕ[1/2]>> 1> Out[1]= Sqrt[Pi] PolyGamma[0, -]> 2>>
In[2]:= FullSimplify[%]>> 1> Out[2]= Sqrt[Pi] PolyGamma[0,
-]> 2>> In[3]:= FunctionExpand[%]>> Out[3]= Sqrt[Pi]
(-EulerGamma - Log[4])>> According to the FunctionExpand
help, it is automatically called by> FullSimplify. Why am I
not getting Out[3] after the FullSimplify?> Certainly it is
simpler than Out[2].>> -Nevin>Not according to MatheamticaÕs
default meaning of simpler:In[1]:=v =
Derivative[1][Gamma][1/2]Out[1]=Sqrt[Pi]*PolyGamma[0,
1/2]In[2]:=FullSimplify[v]Out[2]=Sqrt[Pi]*PolyGamma[0,
1/2]In[3]:=LeafCount[%]Out[3]=11In[4]:=FunctionExpand[v]Out[4
]=Sqrt[Pi]*(-EulerGamma -
Log[4])In[5]:=LeafCount[%]Out[5]=14If you replace Leaf count
by Depth and other usual measures of complexity still the
first answer comes out as simpler. Here is one possible way to
force the second to be regarded as
simpler:In[9]:=FullSimplify[v, ComplexityFunction ->
(StringLength[ToString[#1]] & )]Out[9]=Sqrt[Pi]*(-EulerGamma
- Log[4])Andrzej KozlowskiYokohama,
Japanhttp://www.mimuw.edu.pl/~akoz/http://
platon.c.u-tokyo.ac.jp/andrzej/Reply-To:
selwynh@earthlink.net
====
If you look at your i2[t]
expression, youÕll see that it has a term involving
DiracDelta[t-.5]. There is no way a numerical algorithm is
going to deal correctly with that. HereÕs a simple, though
not totally satisfactory, work-around:First define an
approximate Dirac distribution (a pulse with width r):
nDelta[x_, r_] := (UnitStep[x + r/2] - UnitStep[x -
r/2])/rThen replace the DiracDelta function in i2[t] with
nDelta: ni2[t_] = i2[t]/.DiracDelta[x_] -> nDelta[x,.001];
NDSolve[{i1[t] == ni2[t], vout[0] == 0}, vout, {t, 0, 10.},
MaxStepSize->.001, MaxSteps->10^5]Note that the setting for
MaxStepSize is the same as the width of the pulse. YouÕll 
see
that the result agrees fairly well with your physical
solution.---Selwyn Hollis
====
> Dear Math expert,>> I am
trying to use NDSolve to solve a circuit where a component>
changes its value at some time. NDSolve (Mathematica version
4 on an> IBM PC running Windows 98SE) misses the transient.>>
The simplest circuit (which can also be solved analythically)
which> shows the problem can be modelled as an RC circuit
with a step input.> At time t0 a capacitor ... ...> ...>> As
can be seen in the notebook, NDSolve misses the transient,
and> computes an almost exact rising exponential with the
initial time> constan (R * C).> ...>
---------------------------------------->> If you look at
your i2[t] expression, youÕll see that it has a term>
involving DiracDelta[t-.5]. There is no way a numerical
algorithm is> going to deal correctly with that. HereÕs a
simple, though not totally> satisfactory, work-around: ...>
...> ----------------------------------------Yes, the problem
is in the presence of the Dirac function, whichcannot be
directly handled numerically.There is however a way to treat
these problems which use to work with linearODEs (your case):
change variables V(t) -> v(t) g(t), where V(t) is thedependent
variable of your ODE and g(t) is some function to be
determinedsuch that: neither g(t) nor the resulting ODE in
v(t) contain Diracfunctions. Finally plotting v(t) g(t) you
obtain the plot for your originalproblem in V(t).Example. (-1
- Dirac(t - 5)) vout UnitStep(t) vout'=
------------------------ + ------------------- 1 + UnitStep(t
- 5) 1 + UnitStep(t - 5)where vout(t) is the dependent
variable. Searching for vout(t) = v(t) g(t)with g having the
properties mentioned, by eye, g(t) = 1/(1 + UnitStep(t -
5))is a solution, since it does not contain Dirac, and
through vout = v g,it leads to an ODE in v also free of Dirac
v v'+ ------------------- - UnitStep(t) = 0 1 + UnitStep(t 
-
5)So, noting that vout(0) = v(0) = 0, solve numerically this
ODE in v andplot v g to obtain the plot of the solution to
your original problem in V.In above one could still object
the guesswork in finding an appropriateg(t). A manner of
avoiding this guesswork is based in the observation that
afunction g(t), with properties as the one mentioned,
typically has itsderivative expressed in terms of Dirac (that
is why the ODE in the newvariable v(t) has no Dirac
functions). So formulate the problem for g(t).Example.Change
variables vout(t) = v(t) g(t), with g(t) unknown at this
point,arriving at v g Dirac(t - 5) ------------------- + v 
gÕ
(A) 1 + UnitStep(t - 5) (v'UnitStep(t - 5) + v + 
vÕ) g
UnitStep(t) + ------------------------------- -
------------------- = 0 1 + UnitStep(t - 5) 1 + UnitStep(t -
5)Take now the terms in above containing Dirac and g'only,
equate themto zero and solve for g: v g Dirac(t - 5)
-------------------- + v g'= 0 1 + UnitStep(t - 5) g = C[1]
Exp(- UnitStep(t - 5))and there you are, with a generic g(t)
solving your problem. Take C[1]=1for simplicity, and your ODE
in v(t) free of Dirac, from (A) above, is (v'UnitStep(t - 
5)
+ v + vÕ) g UnitStep(t) ------------------------------- -
------------------- = 0 1 + UnitStep(t - 5) 1 + UnitStep(t -
5)Again, solve numerically for v and plot v g, representing
the plot of thesolution to your original problem in V.PS:
thanks to Allan Wittkopf who pointed this to me once.Edgardo
S. Cheb-Terrab http://lie.uwaterloo.ca/ecterrabTheoretical
Physics Department UERJ,BrazilCentre for Experimental and
Constructive Mathematics SFU, Canada
====
Wrap your output in
TradionalFormErich> I recall a discussion about ways to
manipulate formulas so as to avoid the> ugly results of
formulas that start with minus and parentheses that start>
with -1, such as -(-1+w)/x... etc.>> I hope I am clear.
(w-1)/p is output as (-1+w)/p. How can we make> Mathematica
print it the pretty way?>> Another fraction comes up with a
leading minus sign where it is easily> removable, but
Simplify[ ] does not remove it. The result is>
-(-1+w)(...)/(x+y)^2> Nicholas>>Reply-To:
halfordf@colorado.edu
====
 I am having trouble installing
mathematica for linux it and wonderedif some of you also
might use it.I put in the cdmounted the drivenothing, and I
mean nothing at all happens.I tried it logged in as root as
well.What is up?Forrest
====
> I am having trouble installing
mathematica for linux it and wondered> if some of you also
might use it.> I put in the cd> mounted the drive> nothing,
and I mean nothing at all happens.are you sure you can
execute files from the CD? if your /etc/fstabsays something
like,----| /dev/hdb /cdrom iso9660 ro,noauto,user 0 0`----you
have to pass some extra option to mount.Albert..
====
Try it
from the command line. ItÕs failing to execute for some
reason(CD mounted noexec, for example), and the GUI isnÕt
showing you an errormessage explaining why. It probably 
wonÕt
work from the command lineeither, but at least youÕll get a
hint about whatÕs happening.Jesse> I am having trouble
installing mathematica for linux it and wondered> if some of
you also might use it.> I put in the cd> mounted the drive>
nothing, and I mean nothing at all happens.> I tried it
logged in as root as well.> What is up?> Forrest> 
====
> I am
having trouble installing mathematica for linux it and
wondered> if some of you also might use it.> I put in the cd>
mounted the drive> clicked on Mathinstaller and nothing, and I
mean nothing at all happens.> I tried it logged in as root as
well.> What is up?Is your CD drive mounted with executable
ßag (or however this is called). A possibility is to use a
line like/dev/cdrom /media/cdrom auto ro,noauto,user,exec 0 0
!^^^^!in the file /etc/fstab-- Hendrik van Hees Fakult.8at
f.9fr Physik http://theory.gsi.de/~vanhees/ D-33615 Bielefeld

====
> maybe you can help me with the following problem:> there
is an iterative function> f[x_]:=.... resulting something like
{values, boolean}> I would like to nest f onto f
repetitativly, however the number is not> fixed in the
beginning, but depends on the output of f (the boolean>
value).> it looks like:> NestWhile[f[#] &, {init,true},
criteria (depending on the output of f, 10]> any hint???>
thank you> h.Just an
example...In[1]:=f[{x_,_}]:=With[{val=x+Random[]},{val,val>=5
}]In[3]:=NestWhileList[f,{0,True},Last]Out[3]={{0,True},{
0.818349,True},{1.47905,True},{2.1265,True},{2.33135,
True},{2.79274,True},{3.24593,True},{3.96528,True},{4.17204,
True},{5.0755, False}}By the way, I canÕt see why you
couldnÕt transfer the criterion on thelast argument of
NestWhile (or NestWhileList) and have f return thevalue
alone...Orestis VantzosReply-To:
kuska@informatik.uni-leipzig.de
====
something like:f[{x_, _}]
:= {x^2 + 1, If[x < 10, True, False]}andNestWhile[f, {1,
True}, Last] Jens> maybe you can help me with the following
problem:> there is an iterative function> f[x_]:=....
resulting something like {values, boolean}> I would like to
nest f onto f repetitativly, however the number is not> fixed
in the beginning, but depends on the output of f (the
boolean> value).> it looks like:> NestWhile[f[#] &,
{init,true}, criteria (depending on the output of f, 10]> any
hint???> thank you> h.
====
NestWhile is maybe the right
function, but your problem seems a little weirdto me. Like
something is being too much. If you had just described it
alittle bolder.Hope that helps a
little:f[x_]:=If[x[LessEqual]100,{x+15,True},{x+1,False}]
NestWhileList[f@First[#]&,{0,True},Last@#[Equal]True&]| maybe
you can help me with the following problem:|| there is an
iterative function| f[x_]:=.... resulting something like
{values, boolean}|| I would like to nest f onto f
repetitativly, however the number is not| fixed in the
beginning, but depends on the output of f (the boolean|
value).| it looks like:| NestWhile[f[#] &, {init,true},
criteria (depending on the output of f, 10]|| any hint???|
thank you| h.||||
====
I get into trouble in evaluating an
integral in three different ways:Integrate[Sin[y]/(y - 2 -
I), {y, -Infinity, Infinity}] - 
Integrate[Sin[y]/y, {y,
-Infinity, Infinity}]//N-3.62254 + 1.0509
IIntegrate[Sin[y](1/(y - 2 - I) - 1/y), {y, -Infinity,
Infinity}]//N-4.1035Integrate[Sin[y](1/(y - 2 - I) - 1/y) //
Factor, {y, -Infinity, Infinity}]//N-2.44208 - 
1.22104 IThe
first one gives true answers. I donÕt know 
mathematica how to
getthe second and third answer.Please help.Thx a lot.Jensen
Li
====
> Steven,>> Use the Fills option.>>
Needs[Graphics`InequalityGraphics`]>
Needs[Graphics`Colors`]>> InequalityPlot[Xor[(x + 1/2)^2 +
y^2 <= 1,> (x - 1/2)^2 + y^2 <= 1], {x}, {y},> Fills ->
{DeepSkyBlue, DeepNaplesYellow}];>> David Park>
djmp@earthlink.net> http://home.earthlink.net/~djmp/> This is
a long-standing issue for me. I would like to be able to
specify a> particular bound region of a graph and determine
what collor to fill the> region with. The InequalityGraphics
does almost what I want. If I could> specify the color with
which to fill each region of the graph produced by> code such
as this example from the help browser I would have my
solution:>> !((InequalityPlot[> Xor[ ((x + 1/2))^2 + y^2 <=
1, ((x - 1/2))^2 + y^2> <= 1], {x}, {y} ];))>> This seems
like it should be a no-brainer, but I have yet to find a>
solution to this. Does anybody know of a way to accomplish
such a thing? > All I want to do is produce a Ven diagram
using the traditional circles> found in textbooks, and fill
the different regions with unique colors.David,some advice
recieved from Bob Hanlon, telling me how to use
DisplayTogether[]. This is my current project, it isnÕt very
pretty WRT Mathematica coding styles for packages, but it
runs. Sorry about all the ugly Mathematica markup, but I
donÕt know of a way to remove that stuff, other than by 
hand.
This was a very instructive project. I started out using
iteration for a lot of stuff, then I realized that Inner[] is
my friend.The files are also available
here:http://baldur.globalsymmetry.com/projects/mma/
ven-diagrams/(* demonstration notebook
*)Needs[Graphics`Colors`]Needs[Graphics`Graphics`]Needs[
Graphics`InequalityGraphics`]Needs[GS`venPlot`](* draw one
diagram *)diagram[#1 || #2 && (! #2 && #3)](* generate all
256 diagrams *)(* This takes a few minutes *)diagramAll[](*
Begin Package Code for venPlot.nb
*)!(((BeginPackage[<GS`venPlot`>, <Graphics`Colors`>,
<Graphics`Graphics`>, <Graphics`InequalityGraphics`>])(n)
)[IndentingNewLine] ((diagram::usage = <diagram[predicate0]
creates a ven diagram of predicate, a three-place boolean
function.>;)(n) )[IndentingNewLine] ((diagramAll::usage =
<diagramAll[showDiagram,showParts] creates all ven diagrams
of three-place boolean functions.>;)([IndentingNewLine]) )n
((Begin[<`Private`>])([IndentingNewLine]) )[IndentingNewLine]
(count = 0;)[IndentingNewLine] (showDiagram = True;)n
((showParts = False;)([IndentingNewLine]) )[IndentingNewLine]
(node[int_, lst_: {}] := rl[node[int - 1, {lst, True}],
node[int - 1, {lst, False}]] /; int > 0;)n ((node[int_, lst_:
{}] := Return[Flatten[lst]];)(n) )[IndentingNewLine]
((booleanList[int_] := List @@ Flatten[rl[node[int]]];)(n)
)[IndentingNewLine] (states = booleanList[8];)n
((propositions = booleanList[3];)([IndentingNewLine])
)[IndentingNewLine] ((nXor[arg_, bool_] := (! Xor[bool,
arg]);)(n) )[IndentingNewLine] ((nifStr[bool_] := If[(!
bool), <.8cå>, <>];)([IndentingNewLine]) )n ((orJoin[ strLst_]
:= [IndentingNewLine]Module[{},
[IndentingNewLine]StringJoin[[IndentingNewLine]Take[strLst,
1], [IndentingNewLine](((< [Or] > <> #1)) &) /@
Rest[strLst][IndentingNewLine]][IndentingNewLine]];)(n)
)[IndentingNewLine] ((strLst = (((nifStr[#1] <> <[Alpha]
[And] > <> nifStr[#2] <> <[Beta] [And] > <> nifStr[#3] <>
<[Gamma]>)) &) @@@ propositions;)(n) )n ((wrap[state_, str_]
:= nifStr[state] <> <(> <> str <> <)>;)(n) )n
((predicateString = Function[{ol, strLst}, orJoin[Inner[wrap,
ol, strLst, List]]];)([IndentingNewLine]) )n
((determineState[predicate_] := (((predicate)) &) @@@
propositions;)([IndentingNewLine]) )[IndentingNewLine]
[CapitalDelta][Theta] = (-((2 [Pi])/4))[IndentingNewLine] ((r
= 1;)([IndentingNewLine]) )[IndentingNewLine]
(([CapitalDelta]r = 1.5 r;)([IndentingNewLine])
)[IndentingNewLine] pt = ((#1 {Cos[#2], Sin[#2]})) &n (pt0 =
pt @@ {r/2, (2 [Pi])/3 +
[CapitalDelta][Theta]};)[IndentingNewLine] (pt1 = pt @@ {r/2,
2 ( 2 [Pi])/3 + [CapitalDelta][Theta]};)[IndentingNewLine]
((pt2 = pt @@ {r/2, 0 +
[CapitalDelta][Theta]};)([IndentingNewLine])
)[IndentingNewLine] (thk =
Thickness[0.01];)[IndentingNewLine] (cir1 = Graphics[{thk,
RGBColor[1, 0, 0], Circle[pt0, r]}];)[IndentingNewLine] (cir2
= Graphics[{thk, RGBColor[0, 1, 0], Circle[pt1,
r]}];)[IndentingNewLine] ((cir3 = Graphics[{thk, RGBColor[0,
0, 1], Circle[pt2, r]}];)([IndentingNewLine])
)[IndentingNewLine] ((staticGLst = {cir1, cir2,
cir3};)([IndentingNewLine]) )[IndentingNewLine] (a = ((x -
pt0[LeftDoubleBracket]1[RightDoubleBracket]))^2 + ((y -
pt0[LeftDoubleBracket]2[RightDoubleBracket]))^2 <=
1;)[IndentingNewLine] (b = ((x -
pt1[LeftDoubleBracket]1[RightDoubleBracket]))^2 + ((y -
pt1[LeftDoubleBracket]2[RightDoubleBracket]))^2 <=
1;)[IndentingNewLine] ((c = ((x -
pt2[LeftDoubleBracket]1[RightDoubleBracket]))^2 + ((y -
pt2[LeftDoubleBracket]2[RightDoubleBracket]))^2 <=
1;)([IndentingNewLine]) )[IndentingNewLine] ((ßTrue =
(RGBColor @@ {[Alpha], [Beta], [Gamma]} /.
[IndentingNewLine]{[Alpha] :> If[#1, 1, 0],
[IndentingNewLine][Beta] :> If[#2, 1, 0],
[IndentingNewLine][Gamma] :> If[#3, 1, 0]} &) @@@
propositions;)([IndentingNewLine]) )[IndentingNewLine]
((ßTrue = ReplacePart[ßTrue, RGBColor @@ {0.5, 0.5, 0.5},
(-1)];)([IndentingNewLine]) )[IndentingNewLine] ((plts =
(Inner[nXor, {a, b, c}, #, List] &) /@ propositions;)(n)
)[IndentingNewLine] (diagram[predicate0_, showDiagram0_:
True, showParts0_: False] := (([IndentingNewLine]showDiagram
= showDiagram0; [IndentingNewLine]showParts = showParts0;
[IndentingNewLine]If[count > 0, Print[ToString[(count++)]]];
[IndentingNewLine]Block[{predicate = predicate0},
[IndentingNewLine]tLst = determineState[ predicate];
[IndentingNewLine][IndentingNewLine]ß = (Inner[ If[#, #2,
RGBColor @@ {0, 0, 0}] &, {##}, ßTrue, List] &) @@ tLst;
[IndentingNewLine][IndentingNewLine]iqpLst = {};
[IndentingNewLine][IndentingNewLine]Do[[IndentingNewLine]
iqpLst = {iqpLst,
InequalityPlot[[IndentingNewLine]plts[LeftDoubleBracket]i[
RightDoubleBracket], [IndentingNewLine]{x, (-2), 2},
[IndentingNewLine]{y, (-2), 2}, [IndentingNewLine]Fills ->
{ß[LeftDoubleBracket]i[RightDoubleBracket]},
[IndentingNewLine]Axes -> False,
[IndentingNewLine]DisplayFunction -> If[showParts,
$DisplayFunction, Identity][IndentingNewLine]]},
[IndentingNewLine]{i, Length[plts]}];
[IndentingNewLine][IndentingNewLine]ipqLst = Flatten[iqpLst];
[IndentingNewLine]gLst = Flatten[{iqpLst, staticGLst}];
[IndentingNewLine][IndentingNewLine]If[ showDiagram,
[IndentingNewLine]Print[<begin diagram ---------------->>];
[IndentingNewLine]Print[ predicateString[tLst, strLst]];
[IndentingNewLine]DisplayTogether[[IndentingNewLine]gLst,
[IndentingNewLine]ImageSize -> 488];
[IndentingNewLine]Print[<<-------------- end diagram >];,
[IndentingNewLine]Return[
gLst][IndentingNewLine]][IndentingNewLine]]));)[
IndentingNewLine][IndentingNewLine]
(diagramAll[showDiagram0_: True, showParts0_: False] :=
Block[{predicateTests, predicates},
[IndentingNewLine]showDiagram = showDiagram0;
[IndentingNewLine]showParts = showParts0;
[IndentingNewLine]count = 1;
[IndentingNewLine][IndentingNewLine]predicateTests = And @@@
(((Inner[nXor, {x, y, z}, {##}, List] &) @@@ propositions));
[IndentingNewLine]predicateTests = predicateTests /. {x :>
#1, y :> #2, z :> #3}; [IndentingNewLine]predicates =
(Inner[And, predicateTests, {##}, Or] &) @@@ states;
[IndentingNewLine]ret = (diagram[#1, showDiagram, showParts]
&) /@ predicates; [IndentingNewLine]Return[
ret];[IndentingNewLine]];)[IndentingNewLine]n End[]n
EndPackage[])(* End package Code for venPlot.nb *)--
STHHattonÕs Law: There is only One inviolable Law.
====
hii
have the following problem:i am creating a index notebook for
some notebooks that are located in a subdirectory (e.g.
/dir1/index.nb points to nb files /dir1/dir2/1.nb
/dir1/dir2/2.nb) this should be done independent of the
topdir everything is located in and independent of the
operating system used. i use a script to generate the dir and
name.nb strings and they are pasted correctly into the
ButtonFunction.a friend of mine suggested to use
ButtonBox[aszdfg, ButtonData:>{ FrontEnd`FileName[ {dir},
name.nb, CharacterEncoding -> ISO8859-1] } ,....however, this
does not work. i tried some things and ended
withButtonBox[open, ButtonFunction:>{ FrontEnd`NotebookOpen[
FrontEnd`FileName[ {dir}, name.nb, CharacterEncoding ->
ISO8859-1]]}, ButtonStyle->Hyperlink]however, this does not
work, either.is there a clean way to set hyperlinks with
relative paths ??thanks for your helpgerald roth--
*************************************Gerald RothM@th Desktop
Development*************************************
====
To all of
those that replied, THANKS! Your answers made me realized that
Ihave to be careful in my assumptions with Mathematica. As
Adam mentioned, Iwas raised with FORTRAN IV ... so I have to
be careful on what IÕm doingwith expressions that I use in
other languages.Robert-----Original
Message-----c={{a[[1]],b[[1]]},{a[[2]],b[[2]]},{a[[3]],b[[3]]
}}This works because you are explicitly defining c. With the
equal signand a completed list Mathematica can create the 3X2
list c and assignthe values. In effect Mathematica treats =
very intelligently anddoes a great deal behind the
scenes.However the Do construction is dumber in a sense.
There is noassignment to a variable name inside the do loop.
Mathematica indeeddoes the steps, but does not store them
anywhere. You can see this byPrint[ ]Do[Print[ {a[[i]],
b[[i]]}], {i, 3}]The correct element print out, but then
evaporate. With a Do construction, you must first create an
appropriate sizedvariable name. Then you make the assignment.
I use the name d inthe example below.d = Array[ , {3, 2}] (*
Creates a null 3X2 array named d *)Do[d[[i, 1]] = a[[i]];
d[[i, 2]] = b[[i]];, {i, 3}]This will do what you want. Note
that I made two assignments in thedo loop.But as others will
point out, it is not the way to do it inMathematica. You
discovered the Transpose way. One can also use:f =
Thread[{a,b}]Thread and Transpose have the big advantage that
you donÕt have toknow the size of null array before
preceeding. They are also muchquicker than the Do loop. With
Transpose being the quickest, Ibelieve.Adam Smith > Good
day,> Here what I am trying to do:> <<...OLE_Obj...>>
<<...OLE_Obj...>> <<...OLE_Obj...>> <<...OLE_Obj...>> Of
course my two lists are a lot larger ! So, I would like to
build thenew> list c automatically, from the first item to the
last of my lists (numberof> items is equal in both lists). I
tried:> <<...OLE_Obj...>> <<...OLE_Obj...>> and other things.
But it does not work.> At the end I want to plot (ListPlot)
the new list.> Any suggestion?> Robert Pigeon
====
Can anyone
help me solve this by induction3 to the power n < n!, when n
is > 6-Sam
====
I am not sure what you are really trying to do.
An inductive proof isprobably not the way to
go.FindRoot[3^n==n!,{n,4,7}]gives an answer of about 6.016.
An examination of the slope of the twocurves shows that each
is monotonically increasing, and n! has the largerpositive
slope. If you use StirlingÕs approximation for the 
factorial,
youcan get a better functional feel for it. If you take the
log of the twoterms you compare n Log[3] with n Log[n]-n
(StirlingÕs approx for log n!) itis clear that the latter is
increasing faster.Kevin>> Can anyone help me solve this by
induction>> 3 to the power n < n!, when n is > 6>
-Sam>>
====
Sam,Using Mathematica we might do it this way.
First check that it is true forsome low numbers greater than
6.Table[{n, 3^n, n!}, {n, 6, 15}] // TableFormIt looks like
it is so maybe itÕs worthwhile attempting a proof. Paste
inand evaluate the following for the proof.Print[We wish to
show the following for n > 6]step1 = 3^n < n!Print[It is true
for n == 7]step1 /. n -> 7Print[Assuming it is true for n,
then for n+1...]step2 = step1 /. n -> n + 1step3 = step2 /.
{3^(n + 1) -> 3*HoldForm[3^n], (1 + n)! ->
n*HoldForm[n!]}Print[Using 3 < n and !(3^n)<
n!..]Simplify[step3, 3 < n && HoldForm[3^n] < HoldForm[n!] &&
HoldForm[3^n] > 0]David
Parkdjmp@earthlink.nethttp://home.earthlink.net/~djmp/Sender:
steve@smc.vnet.netApproved: Steven M. Christensen
<steve@smc.vnet.net>, Moderator
====
there must be a syntax
error..Could you help me find it?f = Function[pp, Module[{r,
aux}, r = new; aux = pp; While[emptyQ[aux] == False,
While[emptyQ[top[aux]] == False, r = push[top[top[aux]], r];
aux = push[pop[top[aux]] , pop[aux]] ]; aux = pop[aux] ]
r]]it gives gack something estrange when applyed to a list of
list. Like: {3Null,7Null...etc}
====
Nicholas doesnÕt like
getting things like (-1+w)/p in output and wouldrather get
(w-1)/p which looks better.Two solutions to this problem are
posted
at:http://www.verbeia.com/mathematica/tips/HTMLLinks/Tricks_
188.html-----Also the solution at
http://www.verbeia.com/mathematica/tips/HTMLLinks/Tricks_99.
htmlwill solve this problem in many cases. ---------- Ted
ErsekDownload my entire collection of tricks from:
http://www.verbeia.com/mathematica/tips/Tricks.htmland
http://www.verbeia.com/mathematica/tips/GraphicsTricks.html==
==When you insert text into Mathematica graphics, a large
number of the characters or symbols are invisibly converted
from Helvetica, or whatever text font you may be using, into
one of MathematicaÕs Symbol fonts, which are called
Math-something-or-other. This includes a fair number of
characters which are standard in the text font family and
really donÕt *have* to be converted, including not only math
characters, such as + and = signs but punctuation such as [ ]
brackets.The net result is that when you Export the graphics
to an external PostScript file a string such as Re[x] becomes
four separate and distinct strings, namely Re, [, x and
].Suppose you then import this EPS file into, say, Illustrator
for touch-up and decide you want to make a global increase in
font size for better appearance (something itÕs very easy to
do in Illustrator). If this were a single string Illustrator
would know it should also increase the spacing between the
characters appropriately, even with possibly different fonts
for different characters, and the whole string would still
look OK. With separate substrings, however, the spacing
between them doesnÕt change and the enlarged characters
overlap onto each other. Pulling Ōem apart individually is
very tedious, and I havenÕt identified any 
global way to fix
the problem.-----Power tends to corrupt. Absolute power
corrupts absolutely. Lord Acton (1834-1902) (slightly
modified)Dependence on advertising tends to corrupt. Total
dependence on advertising corrupts totally. -- Modern
equivalent. 
====
Mathematicians,I am student working on
mathematica 4.0, with little formal education of howto use
the program. I have written a notebook that will solve an
mechanicalsituation given 3 points. These 3 points are being
read in via a data file.I donÕt know how to make 
the following
part work.I would like to make a triple-nested for-loop that
will iterate over thevalues of each of the 3 text files where
the data points are located. Iwould then like to run the
notebook segments each time and record the answerin a text
file as well, each time appending to an array, with the 
final
stepas exporting the array as a *.dat fileAny suggestions
would be most beneficial and greatly appreciated.Michael