Introducing the Wolfram Mathematica Tutorial Collection
Wolfram Research
Wolfram Mathematica Tutorial Collection is now available in a
variety of formats to suit your needs: on the web, as PDFs, and,
by popular demand, in print.
The Tutorial Collection gives you targeted instruction with full
information on the functions, capabilities, and unified
architecture of the Mathematica system, all built into one
anthology. Drawn from the in-product documentation of
Mathematica, the collection includes 23 volumes totaling nearly
3700 pages. Topics include core language, mathematics and
algorithms, visualization and graphics, notebooks and documents,
dynamic interactivity, data manipulation, and systems interfaces
and deployment.
For more information, visit:
http://www.wolfram.com/tutorialcollection
Sincerely,
Maryka Baraka
Author and Publisher Support Specialist
Wolfram Research, Inc.
David Bailey
notebook versions, which were presumably used to prepare the PDF files!
David Bailey
http://www.dbaileyconsultancy.co.uk
mark mcclure
> This looks extremely valuable, but why not let people
> download the notebook versions, which were presumably
> used to prepare the PDF files!
Because, you've already got them! Look in
FileNameJoin[{$TopDirectory, "Documentation"}]
Of course, we usually access these notebooks via the
documenation center.
Mark McClure
Bob F
You already do, don't you? The "Virtual Book" and "Function Navigator"
are the interface to all these files that come with Mathematica. The
"Virtual Book/Function Navigator" notebook is located on my Mac at
/Applications/Wolfram/Mathematica.app/Documentation/English/System/
DocumentationNavigator.nb
-Bob
John Fultz
Maybe I'm missing something in your question here, but you should already have
the notebook versions. This was prepared from in-product documentation. If I
am missing something, maybe you could clue me in as to exactly what you're
looking for.
Sincerely,
John Fultz
jfu...@wolfram.com
User Interface Group
Wolfram Research, Inc.
Bill Rowe
>Wolfram Research wrote:
>>You asked for it, and we've created it. The much anticipated
>>Wolfram Mathematica Tutorial Collection is now available in a
>>variety of formats to suit your needs: on the web, as PDFs, and, by
>>popular demand, in print.
>>For more information, visit:
>>http://www.wolfram.com/tutorialcollection
>This looks extremely valuable, but why not let people download the
>notebook versions, which were presumably used to prepare the PDF
>files!
If the collection contains the same information as the online
documentation that comes with Mathematica it seems to me users
would already have the notebooks used to generate the PDF files.
If the information in the collection is different than the
online documentation that comes with Mathematica, I agree
downloading the notebooks would be more useful. But in this
case, I am more interested in the differences. That is, I've no
interest in downloading information in PDF format I already have
in notebook format. But I do have an interest in those parts of
the collection that would supplement the existing documentation.
Mariano Suárez-Alvarez
... and/or produce PDF files with internal hyperlinks at the very many
places where it would be appropriate?
-- m
Jens-Peer Kuska
you miss nothing. The people does not scan the Documentation/Tutorials
directory for useful notebooks and so nobody has found the Notebook
source of the wonderful PDF collection.
Regards
Jens
Bob F
I think people are missing the value and use of these PDF documents.
Yes, Mathematica currently does have the same content (and more as the
"Tutorial Collection" does not seem to have the "How To" examples and
perhaps more, but so far that is all I have noticed as missing in the
new PDF files), but to get to it you might have to click many, many,
mnay links to get to it. Surely people don't enjoy having to do all
the clicking of links and going back and forth between windows that
the DC user interface forces one to do?
In these new PDF versions, the entire topic is within one single
document. You can now do a search in the PDF file for some string and
get ALL the occurences. In my use of the DC, the search mechanism
within the Documentation Center gets extraneous content and also
misses some important content IMO. But, now that you have the PDF
file, you get a summary of all the occurances of what you are looking
for visible alongside of the content (in Acrobat Pro anyway - not sure
about other PDF viewers), so you don't spend so much time going back
and forth looking for things the way you do in the DC - just another
click in the search window which is adjacent to the main PDF window.
IMO a better documentation interface is a combination of what both the
PDF and the DC interface has plus the ability to "split" a window
(either horizontally or vertically as the need arose) so that you can
scroll in both halves and read two different parts at the same time,
or even more than two if you want (plus the ability to go decrease the
number of splits back to just one if you want). Something like what
vim or emacs or many other editor programs do that people use and have
been using for many many years. The DC user interface is good, but it
could be better.
In fact this divided screen ability would be so very handy for
notebook windows as well. Would save a LOT of time in scrolling around
to find something that happened before and that you would dearly love
to have visible on the screen at the same time as you are typing
something many many lines below it that used some part of what was
screens above or below the current position.
Another user interface issue I would like to see -- it would be so
nice to have some sort of "auto completion" mode your could turn on or
off as you needed -- perhaps a template of the command as you type.
Something that would supply the complete command and you simply change
it as you go to fit your needs, plus once you have the basic command,
there should be some way to modify it by perhaps right-clicking and
have all the optional parameters displayed and you pick and choose
which are needed. This would be so much more productive than looking
up the command in the DC, reading thru pages and pages of options
sometimes and finally finding the one that is needed, and then back to
the notebook and type in the just found optional parameter.
-Bob
AES
very much in agreement about the value of PDF documentation. Let me
just add one note.
Split windows are certainly good, particularly if you have either large
(or multiple) monitors and/or excellent eyesight.
An equally good, maybe even better, alternative is to be able to jump
back and forth (preferably with a single keystroke or mouseclick)
between two different full-screen "environments" or "views", with
Mathematica open and running in one of these and the PDF documentation
open and viewable in some reader-friendly application in the other.
The "Spaces" capability in Apple's Leopard OS provides a sophisticated
way to do this; the Cmd-Tab application switching capability in earlier
Mac operating systems is almost equally handy. I'd assume there are
equivalent capabilities on most other platforms.
A non-trivial side benefit is that in this situation you know where you
are at all times; and some accidental or mistaken keystroke in one space
can't mess up what you're doing in the other space.
=====================================================
In article <gtrl4a$1pp$1...@smc.vnet.net>, Bob F <deepy...@gmail.com>
wrote:
Thomas Münch
Collection]
> Another user interface issue I would like to see -- it would be so
> nice to have some sort of "auto completion" mode your could turn on or
> off as you needed -- perhaps a template of the command as you type.
> Something that would supply the complete command and you simply change
> it as you go to fit your needs, plus once you have the basic command,
> there should be some way to modify it by perhaps right-clicking and
> have all the optional parameters displayed and you pick and choose
> which are needed. This would be so much more productive than looking
> up the command in the DC, reading thru pages and pages of options
> sometimes and finally finding the one that is needed, and then back to
> the notebook and type in the just found optional parameter.
>
> -Bob
Dear Bob -
there IS an autocompletion function - simply press Ctrl-K after the
first couple of characters of your function name.
As for the options of a function: Here is a nifty little routine that
I have written to do just what you want. Execute the following code,
which will create a small palette with 2 buttons. Then, highlight a
function name in your notebook (or simply have your cursor within or
directly after the function name, for example "Plot"), and press one
of the buttons. You will get another palette with all the options of
your function. Clicking one of the options will insert it into your
notebook (together with a preceding comma), including the default
value, which will be highlighted so that you can immediately start
typing to replace it with your value of choice, or keep clicking on as
many options as you want. Clicking on the question mark next to an
option will open the appropriate help page in the Documentation
Center. Clicking on the function name at the top of the palette will
open the function's help page.
Normally, the button 'Options (tooltips)' will be the preferred
choice, as you will get informative tooltips in your palette which
show you the default value of the option (when hovering over the
option name), and the usage of the option (when hovering over the
question mark). However, some functions have an enormous amount of
options. Try, for example, 'CreateWindow'. Then it can take quite some
time (several seconds) to create the Options palette. But, the added
benefit of the tooltips might be worth the wait.
If you call the options for another function while an option palette
is still open, the currently open palette will be replaced by the new
one in a way that the top right corner of the new palette window is at
the same position as the previous one. To implement this, I save the
option palette notebook object in the global variable
$optionPaletteCreatedByThisFunction. (This behavior is a feature, as
people might want to move the palette to a second screen, and want it
to remember the position when they call the options for another
function). However, I am not sure that this is the perfect way to
implement it. If you move a wide palette window (many options, e.g.
for 'CreateWindow') off to the side, so that its right corner is far
off-screen, and call a narrow window (with few options, e.g.
'Column'), the new window will be invisible. Maybe someone has a
better idea.
Version restriction: This works only for version 7, as I am using
scroll bars within 'Pane'. It does sort of work with version 6, but
not really.
Note: The original idea for this came from Syd Geraghty, who should be
acknowledged for his work. We worked together to improve the
functionality of the code.
Here is the code:
makeOptionsButton[tooltips_: True] :=
Button[If[tooltips, "Options (tooltips)", "Options (no tooltips)"],
Module[{fun, clen, len, buttons, title, columns, opts,
maxPanelHight = 800, windowPos, insert,
maximumNumberOfColumns = 3, tooltipfunction},
tooltipfunction =
If[tooltips, # &,
First];(*determines whether or not to show tooltips*)
(*Extract the currently selected funtion*)
SelectionMove[InputNotebook[], All, Word];
fun = ToExpression@ NotebookRead[InputNotebook[]];
SelectionMove[InputNotebook[], After, Word];
If[Head[fun] =!= Symbol, Return[]];
opts = Options[fun]; (*read the options*)
len = Length[opts];
columns = Max[1, Min[maximumNumberOfColumns, Ceiling[len/30]]];
clen = Ceiling[len, columns];(*some numbers for formatting*)
(*This is the function that inserts the option into the notebook \
when the button is pressed, and selects the option value*)
insert[
option_] := (NotebookWrite[InputNotebook[],
RowBox[{",", ToBoxes[option[[1]]],
StringJoin["\[", ToString@Head@option, "]"]}]];
NotebookWrite[InputNotebook[], ToBoxes[option[[2]]], All]);
If[len > 0,
(* If fun has Options: *)
buttons =
Grid[{{tooltipfunction@
Tooltip[
ReleaseHold@
MakeExpression@
ButtonBox["\" ? \"",
ButtonData ->
"paclet:ref/" <> ToString[Evaluate[#[[1]]]],
Appearance -> "Palette", BaseStyle -> "Link",
ButtonFrame -> None], Evaluate[#[[1]]]::usage],
tooltipfunction@
Tooltip[
Button[#[[1]], insert[#], Alignment -> Left,
Appearance -> "Palette"],
Column[{"Default value:", #}]]}}] & /@
opts;(*For each option,
create a 'help' button and a button for pasting the option*)
buttons =
Grid[Partition[PadRight[buttons, clen, ""],
clen/columns]\[Transpose], Spacings -> {0, 0.05},
Alignment -> Left];(*arrange into a Grid*)
title =
"Options for " <> ToString@fun <> " (Click option to insert)",
(* If fun does not have any Options: *)
buttons =
Style[ToString[fun] <> " does not have any Options", Bold,
White];
title = "Usage of " <> ToString@fun
];
(*Some code to keep the upper right corner of the new options \
palette window identical to the currently open one.*)
With[{test =
AbsoluteOptions[$optionPaletteCreatedByThisFunction,
WindowMargins]},
windowPos =
If[Head[test] === List, test[[1, 2]], {{0, 0}, {0, 0}}];
windowPos[[All, 1]] = Automatic];
(*This closes the previous Options Pallette*)
NotebookClose[$optionPaletteCreatedByThisFunction];
(*This creates a new palette and assigns it to the global variable
\
$optionPaletteCreatedByThisFunction*)
$optionPaletteCreatedByThisFunction =
CreateWindow[
PaletteNotebook[
Column[{Tooltip[
ToExpression@
ButtonBox[Style[ToString[fun] <> " =BB", Bold],
ButtonData -> "paclet:ref/" <> ToString[fun],
BaseStyle -> "Link", ButtonFrame -> None],
ToExpression[ToString[fun] <> "::usage"]],
Pane[buttons, ImageSize -> {Automatic, {maxPanelHight}},
Scrollbars -> Automatic]}], ShowStringCharacters -> False,
WindowTitle -> title, Saveable -> False,
WindowMargins -> windowPos]];
]]
CreatePalette[Row[makeOptionsButton /@ {True, False}],
Saveable -> False, WindowTitle -> "Options for selected function"];
Bob F
> [From former thread: Introducing the Wolfram Mathematica Tutorial
> Collection]
>
> > nice to have some sort of "auto completion" mode your could turn on or
> > off as you needed -- perhaps a template of the command as you type.
> > Something that would supply the complete command and you simply change
> > it as you go to fit your needs, plus once you have the basic command,
> > there should be some way to modify it by perhaps right-clicking and
> > have all the optional parameters displayed and you pick and choose
> > which are needed. This would be so much more productive than looking
> > up the command in the DC, reading thru pages and pages of options
> > sometimes and finally finding the one that is needed, and then back to
> > the notebook and type in the just found optional parameter.
>
> > -Bob
>
]],
> Appearance -> "Palette", BaseStyle -> "Lin=
k",
> ButtonFrame -> None], Evaluate[#[[1]]]::us=
age],
> tooltipfunction@
> Tooltip[
> Button[#[[1]], insert[#], Alignment -> Left,
> Appearance -> "Palette"],
> Column[{"Default value:", #}]]}}] & /@
> opts;(*For each option,
> create a 'help' button and a button for pasting the option*)
> buttons =
> Grid[Partition[PadRight[buttons, clen, ""],
> clen/columns]\[Transpose], Spacings -> {0, 0.05},
> Alignment -> Left];(*arrange into a Grid*)
> title =
lse,
> WindowTitle -> title, Saveable -> False,
> WindowMargins -> windowPos]];
> ]]
>
> CreatePalette[Row[makeOptionsButton /@ {True, False}],
> Saveable -> False, WindowTitle -> "Options for selected function"];
Very interesting. Thanks very much. I like that it gives all the
options for a routine, but it doesn't show all the possible values for
each of the options. Have you seen anything that also has that?
-Bob