(*********************************************************************** Mathematica-Compatible Notebook This notebook can be used on any computer system with Mathematica 3.0, MathReader 3.0, or any compatible application. The data for the notebook starts with the line of stars above. To get the notebook into a Mathematica-compatible application, do one 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 be sent directly in email or through ftp in text mode. Newlines can be CR, 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 containing the word CacheID, otherwise Mathematica-compatible applications may try to use invalid cache data. For more information on notebooks and Mathematica-compatible applications, contact Wolfram Research: web: http://www.wolfram.com email: info@wolfram.com phone: +1-217-398-0700 (U.S.) Notebook reader applications are available free of charge from Wolfram Research. ***********************************************************************) (*CacheID: 232*) (*NotebookFileLineBreakTest NotebookFileLineBreakTest*) (*NotebookOptionsPosition[ 47152, 1326]*) (*NotebookOutlinePosition[ 48028, 1355]*) (* CellTagsIndexPosition[ 47984, 1351]*) (*WindowFrame->Normal*) Notebook[{ Cell[CellGroupData[{ Cell["V3.0: Manifest Destiny", "Title"], Cell["Or, what have we been up to for the last decade or so?", "Subsubtitle"], Cell[CellGroupData[{ Cell["by Theodore W. Gray", "Subsection"], Cell[TextData[{ "The ", StyleBox["Mathematica", FontSlant->"Italic"], " front end has undergone many changes over its 9 year life. In this \ article we will see how some of the features present in V3.0 developed and \ changed over time." }], "Text"], Cell[TextData[{ "The original vision of the front end was to provide a document interface \ to the ", StyleBox["Mathematica", FontSlant->"Italic"], " kernel. I decided very early that we would create an environment in \ which you could not only interact with the kernel, but at the same time \ create a permanent, editable record of what you did. This would overcome the \ biggest drawback to using a UNIX terminal interface, which was that when you \ were done, you had nothing you could easily refer to in the future, or pass \ on to colleagues. " }], "Text"], Cell["\<\ Since at the time the kernel used only plain ASCII text for input \ and output, the interface would necessarily concentrate on text. I ruled out \ a 2-D drawing type interface (like MathCad) on the grounds that extensive \ editing of large documents is nearly impossible: Inserting new material in \ the middle of such a document is impractical.\ \>", "Text"], Cell["\<\ So, we arrived an an interface that was basically similar to a word \ processor: A vertically scrolling document in which you could enter text at \ will.\ \>", "Text"] }, Open ]], Cell[CellGroupData[{ Cell["Cells", "Section"], Cell[TextData[{ "One of the very first decisions I made was that the front end would \ organize text into clearly visible units, cells, rather than provide a \ seamless, contiguous stream of text. The strongest motivation for this was \ the Macintosh MPW programming environment, which does ", StyleBox["not", FontSlant->"Italic"], " have a concept like cells." }], "Text"], Cell["The advantages of cells are:", "Text"], Cell[TextData[ "\[Bullet] Multi-line input can be evaluated without first manually selecting \ the range to be evaluated. Without cells, it would be necessary to manually \ indicate the range of input to be evaluated each time, as is necessary in \ MPW."], "Text", CellMargins->{{49, Inherited}, {Inherited, Inherited}}], Cell[TextData[ "\[Bullet] When input is evaluated repeatedly, old output from previous \ evaluations can be deleted automatically. Without cells, there would be no \ clear indication of what is output v.s. input, and therefore no way to know \ what to delete."], "Text", CellMargins->{{49, Inherited}, {Inherited, Inherited}}], Cell["\<\ Initially, we had only a linear sequence of cells, and instead of \ cell brackets we had vertical gray bars that indicated the range of text in a \ cell. It was due to a suggestion from Steve Jobs that we started using \ brackets: They graphically reinforce the notion that text within a cell is \ connected.\ \>", "Text"], Cell[TextData[{ "It was clear early on that some form of outline capability would be \ valuable. Because output from ", StyleBox["Mathematica", FontSlant->"Italic"], " can be very long, documents quickly become very, very long and hard to \ navigate. The first idea was to collapse ranges of cells, leaving only the \ first and last cell visible, with a striped area indicating the missing \ cells. This quickly evolved into the notion of nested groups of cells, which \ was implemented very shortly before the release of V1.0." }], "Text"], Cell[TextData[{ "At first, there were only two types of cells: text and PostScript. Over \ time, additional graphics formats were added (PICT, QuickTime, NeXT Bitmap). \ In V3.0, we added typeset cells, implemented by Neil Soiffer, which contain \ editable 2-D mathematical expressions. This is the most significant addition \ to ", StyleBox["Mathematica", FontSlant->"Italic"], " in many years, because it allows interactive editing of input and output \ in full typeset notation. We added OLE cells to support that protocol in \ Microsoft Windows." }], "Text"], Cell[TextData[{ "In V3.0 we also introduced inline-cells, which means that cells (typeset \ or graphics) can be inserted inside of text cells. This concept is, of \ course, commonly available in word processors as inline graphics. It allows \ formulas like ", Cell[BoxData[ \(TraditionalForm \`\(\(-b\) \[PlusMinus] \@\(b\^2 - 4 a\ c\)\)\/\(2 a\)\)]], " or graphics like ", Cell[GraphicsData["PostScript", "\<\ %! %%Creator: Mathematica %%AspectRatio: .61803 MathPictureStart /Mabs { Mgmatrix idtransform Mtmatrix dtransform } bind def /Mabsadd { Mabs 3 -1 roll add 3 1 roll add exch } bind def %% Graphics /Courier findfont 6 scalefont setfont % Scaling calculations 0.5 0.476191 0.014715 0.588604 [ [.02381 .00222 -3.6 -5.4 ] [.02381 .00222 3.6 0 ] [.2619 .00222 -7.2 -5.4 ] [.2619 .00222 7.2 0 ] [.7381 .00222 -5.4 -5.4 ] [.7381 .00222 5.4 0 ] [.97619 .00222 -1.8 -5.4 ] [.97619 .00222 1.8 0 ] [.4875 .13244 -10.8 -2.7 ] [.4875 .13244 0 2.7 ] [.4875 .25016 -10.8 -2.7 ] [.4875 .25016 0 2.7 ] [.4875 .36788 -10.8 -2.7 ] [.4875 .36788 0 2.7 ] [.4875 .4856 -10.8 -2.7 ] [.4875 .4856 0 2.7 ] [.4875 .60332 -3.6 -2.7 ] [.4875 .60332 0 2.7 ] [ 0 0 0 0 ] [ 1 .61803 0 0 ] ] MathScale % Start of Graphics 1 setlinecap 1 setlinejoin newpath 0 g .25 Mabswid [ ] 0 setdash .02381 .01472 m .02381 .02097 L s [(-1)] .02381 .00222 0 1 Mshowa .2619 .01472 m .2619 .02097 L s [(-0.5)] .2619 .00222 0 1 Mshowa .7381 .01472 m .7381 .02097 L s [(0.5)] .7381 .00222 0 1 Mshowa .97619 .01472 m .97619 .02097 L s [(1)] .97619 .00222 0 1 Mshowa .125 Mabswid .07143 .01472 m .07143 .01847 L s .11905 .01472 m .11905 .01847 L s .16667 .01472 m .16667 .01847 L s .21429 .01472 m .21429 .01847 L s .30952 .01472 m .30952 .01847 L s .35714 .01472 m .35714 .01847 L s .40476 .01472 m .40476 .01847 L s .45238 .01472 m .45238 .01847 L s .54762 .01472 m .54762 .01847 L s .59524 .01472 m .59524 .01847 L s .64286 .01472 m .64286 .01847 L s .69048 .01472 m .69048 .01847 L s .78571 .01472 m .78571 .01847 L s .83333 .01472 m .83333 .01847 L s .88095 .01472 m .88095 .01847 L s .92857 .01472 m .92857 .01847 L s .25 Mabswid 0 .01472 m 1 .01472 L s .5 .13244 m .50625 .13244 L s [(0.2)] .4875 .13244 1 0 Mshowa .5 .25016 m .50625 .25016 L s [(0.4)] .4875 .25016 1 0 Mshowa .5 .36788 m .50625 .36788 L s [(0.6)] .4875 .36788 1 0 Mshowa .5 .4856 m .50625 .4856 L s [(0.8)] .4875 .4856 1 0 Mshowa .5 .60332 m .50625 .60332 L s [(1)] .4875 .60332 1 0 Mshowa .125 Mabswid .5 .04415 m .50375 .04415 L s .5 .07358 m .50375 .07358 L s .5 .10301 m .50375 .10301 L s .5 .16187 m .50375 .16187 L s .5 .1913 m .50375 .1913 L s .5 .22073 m .50375 .22073 L s .5 .27959 m .50375 .27959 L s .5 .30902 m .50375 .30902 L s .5 .33845 m .50375 .33845 L s .5 .39731 m .50375 .39731 L s .5 .42674 m .50375 .42674 L s .5 .45617 m .50375 .45617 L s .5 .51503 m .50375 .51503 L s .5 .54446 m .50375 .54446 L s .5 .57389 m .50375 .57389 L s .25 Mabswid .5 0 m .5 .61803 L s 0 0 m 1 0 L 1 .61803 L 0 .61803 L closepath clip newpath .5 Mabswid .02381 .60332 m .06244 .51168 L .10458 .42058 L .14415 .34341 L .18221 .27686 L .22272 .21429 L .26171 .16211 L .30316 .11529 L .34309 .07863 L .3815 .05117 L .40095 .04018 L .42237 .03036 L .44268 .02324 L .45178 .02075 L .46172 .01852 L .4671 .01752 L .4721 .01674 L .47727 .01606 L .48196 .01556 L .48658 .01518 L .4887 .01505 L .49093 .01493 L .49332 .01483 L .49438 .0148 L .49552 .01477 L .49675 .01474 L .49789 .01473 L .49859 .01472 L .49925 .01472 L .50049 .01472 L .50163 .01472 L .50286 .01474 L .50401 .01476 L .50508 .01478 L .50754 .01486 L .51014 .01498 L .51268 .01513 L .51504 .0153 L .5204 .0158 L .5293 .01694 L .53882 .01863 L .54906 .02096 L .56016 .02411 L .58032 .03146 L .60019 .04077 L .62123 .05287 L .65912 .08044 L .69946 .11799 L .73829 .1621 L .77956 .21759 L Mistroke .81932 .2794 L .85757 .34659 L .89827 .42644 L .93745 .51144 L .97619 .60332 L Mfstroke % End of Graphics MathPictureEnd \ \>"], "Graphics", ImageSize->{76, 46.75}, ImageMargins->{{0, 0}, {0, 23.125}}, ImageRegion->{{0, 1}, {0, 1}}, ImageCache->GraphicsData["Bitmap", "\<\ CF5dJ6E]HGAYHf4PAg9QL6QYHgP400@4100000@400El0001O00002`00 0n003009Q003`00G0004P0U72P000n0000P0000000<000TN2H000n002E0;410000>P00T000>000X0 0H010008000000`000>000X000BP3@LB0005X00=1`l10@01000030000h002P000j003P8B0003X00? 0@l10@0100002`000l003009P003`00G0004P0d73P<00`00000`0003P00/000000P0053o00L00000 :@002<402ahS00009`000l005P8O00009@001<0?0@UP7P0002@000>000T000B03`4L00008`000h00 2P000h002@000h008000028000>000/000>000X000>001l0000Q0003P00<0003P00;0003P00N0000 80001Z09A`U03`4H00007`000j002D09A0`000>001`0000N0004T0U02R@<0003P00K00007@000h00 2E0<2@d000>001X0000M0003P00:80Ub3`000h006P0001`000>0014000>0010000>001T0000K0003 P00B0003P00A0003P00H00006`000h004P000h004P000h005`0001X000>001<000>001<000>001H0 000J00f000>000/B4@000h005P0001T02X09P003`009@0l000>001D0000H0004P0d52RTE0003P00D 00005`000h002@400h002P<00h005@000h00500001L000B03`4;4Q@000>001<0000F0003P00G0003 P00F0003P00C00005P000h005`000h005`000h004P0001D000>001P000>001P000>00140000E0003 P00H0003P00H0003P00A000050000h006@000h006@000h00400001@000>000/000B02D<9@1@000>0 0100000C0003P00;0003X0090@04T1`000>000l0000C0003P00;0005X00:1`03P00J0003P00?0000 4P000h0030000j0030400h006`000h003P00018000>000d000B02P<00h006`000h003P00014000>0 01`000>001`000>000d0000A0003P00L0003P00L0003P00=000040000h007@000h007@000h003000 010000>001d000>001d000>000`0000?0003P00@0004P0U72D0I0003P00;00003P000h0040000j00 2@40190P0003P00;00003P000h0040001:0;0@03P00N0003P00;00003@000h004@000j002@40190Q 0003P00:00003@000h004P00180:1`03P00O0003P00:000030000h008@000h0080000h002@0000`0 00>0024000>0020000>000T0000;0003P00R0003P00Q0003P0002000000;0003P00R0003P00Q0003 P0002000000;0003P00M0003h00:81`000>00008000000X000>001l000>000U07@01P04000P00000 ;0000h002D0W0000;0000h00<00002/000?003400000 \>"], ImageRangeCache->{{{0, 94}, {57.4375, 0}} -> {-1.284, -0.166932, 0.0333506, 0.0269812}}], " to be placed inline with text.\n" }], "Text"] }, Open ]], Cell[CellGroupData[{ Cell["Formatting and Styles", "Section"], Cell[TextData[{ "The first version of ", StyleBox["Mathematica", FontSlant->"Italic"], " allowed only a single font per cell, and a very limited number of \ formatting options. Although primitive in this regard, the front end did \ provide a style sheet mechanism which allowed formatting changes to be made \ globally." }], "Text"], Cell["\<\ Over time, more and more formatting options were added: \ independently adjustable indentation margins, multiple fonts per cell, etc. \ Up until V3.0, only a fixed set of style names could be used. All settings \ defining the styles (the style sheet) were stored privately in each Notebook: \ It was not possible for many notebooks to share the same style definitions.\ \ \>", "Text"], Cell["\<\ In V3.0, a much more flexible style mechanism has been introduced. \ Arbitrary style names can be defined, and style sheets are independent \ entities that can be stored as separate files and referred to by multiple \ notebooks.\ \>", "Text"], Cell[TextData[{ "Perhaps more importantly, in V3.0 all the settings that control the \ display of objects in the front end have been recast as ", StyleBox["Mathematica", FontSlant->"Italic"], "-style options. For example, to control the appearance of text, there are \ options such as:" }], "Text"], Cell[BoxData[ RowBox[{ StyleBox["\(FontFamily \[Rule] \"Times\"\)", "Input"], StyleBox[",", "Input"], "\n", StyleBox["\(FontSize \[Rule] 12\)", "Input"], StyleBox[",", "Input"], "\n", RowBox[{ StyleBox["FontColor", "Input"], "\[Rule]", "\(RGBColor[0.5, 0, 1]\)"}]}]], "Input"], Cell[TextData[{ "You can still use menus to control these things, but because they are \ defined by underlying option names, you can also use ", StyleBox["Mathematica", FontSlant->"Italic"], " programs to control them. In most other applications, the specification \ of these sorts of settings is imprecise at best, because there is no clear \ language design to base the specification on." }], "Text"], Cell[TextData[{ "All objects in the front end (notebooks, cells, text, graphics, \ mathematical expressions, etc) are now represented by ", StyleBox["Mathematica", FontSlant->"Italic"], " expressions. For example, a simple cell in Text style is represented \ by:" }], "Text"], Cell[BoxData[ \(Cell["Hello this is a text cell.", \ "Text"]\)], "Input"], Cell[TextData[{ "A cell containing multiple fonts is represented by a more complex \ structure. For example, ", StyleBox["this", FontSlant->"Italic"], " cell would be represented as:" }], "Text"], Cell[BoxData[ \(Cell[ TextData[{\n\ "A cell containing multiple fonts is represented by a more complex \ structure. For example, ", \n\ StyleBox["this", \n\ \ \ \ FontSlant -> "Italic"], \n\ " cell would be represented as:"\n}], \ "Text"]\)], "Input"] }, Open ]], Cell[CellGroupData[{ Cell["File Format", "Section"], Cell["\<\ File formats can be divided in two ways: Is the format sequential \ or pointer based, and is the format binary or text.\ \>", "Text"], Cell["\<\ In a sequential format, the data (text, graphics, etc) exists in \ the disk file in the same linear order it is displayed. In a pointer based \ file, the data in the file may be in any arbitrary physical order, and a \ table is maintained that tells how to reassemble the scattered pieces into \ the proper order. \ \>", "Text"], Cell["\<\ The biggest difference is in how new material inserted in the \ middle of a document is handled: In a sequential format, the data is inserted \ in the analogous position in the file and the data that follows it is shifted \ down. In a pointer based format, it is added to the end of the file, \ eliminating the need to shift potentially large amounts of data on disk.\ \>", "Text"], Cell["\<\ The problem with pointer based formats is that they are fragile, \ and completely unintelligable outside of the application that created them. \ Because the data is not in order, if you look at the file with a raw data \ editor you may see nothing more than fragments of text scattered at random. \ If the file is damaged, especially if the table portion is effected, the file \ is likely to be completely destroyed. If you don't have the application that \ originally created the file, you have very little chance of being able to \ make much sense of the file.\ \>", "Text"], Cell["\<\ The problem with linear formats is that it can be inefficient to \ shift large amounts of data on disk every time the file is saved. The file \ is also not random access, so in order to display data near the end of the \ file, all the data up to that point must be read in.\ \>", "Text"], Cell["\<\ In the binary v.s. text format axis, there are three main choices: \ Binary, 8-bit ASCII-based, and 7-bit ASCII. (There are many 8-bit encodings \ such as the ISO Latin family, and several dozen Macintosh script system \ encodings, all of which use the ASCII standard to define values up to 127, \ with various assignments for higher values.)\ \>", "Text"], Cell["\<\ A binary format allows all 256 possible values of each byte in the \ file. In some applications, textual data is stored literally with only \ graphics and pointer data in binary format: If the file is examined in a raw \ text editor, the text will be visible. In other applications, the text is \ compressed (to save disk space), and absolutely nothing is recognizable when \ the file is viewed in a raw text editor.\ \>", "Text"], Cell["\<\ In an 8-bit ASCII-based format, the file respects the control \ characters defined by the ASCII standard (i.e., the file does not contain any \ byte values less than 32, except when they are being used for their official \ purpose). A file in this format can be examined with a raw text editor, and \ is likely to make at least some sense. If the text in the file contains \ accented and other special characters, they are stored as byte values between \ 128 and 255: Typically the values used depend on the font that is specified \ for the text in question.\ \>", "Text"], Cell["\<\ In a 7-bit ASCII format, only byte values between 32 and 127 are \ used to represent data in the file. This format is the lowest common \ denominator understood by essentially all current computers (with the \ exception of some antique IBM mainframes). Accented and special characters \ are stored by translating into multi-byte sequences: A typical solution is to \ use octal or hexadecimal encoding for these characters.\ \>", "Text"], Cell[TextData[{ "From the very beginning, we decided that the file format for Notebooks \ would be linear ASCII text, but that we would not accept all the limitations \ this might seem to imply. Because we expected ", StyleBox["Mathematica", FontSlant->"Italic"], " to be used by people with a wide variety of different types of computers, \ we wanted a format that could be transferred very easily. Because we \ expected a lot of academic users, we wanted a format that could be sent by \ email, and at that time email was a text-only format. (Even today, text is \ the only format that can be used compatibly between all the available email \ systems, even those that support one or another binary attachement format.) \ " }], "Text"], Cell["\<\ Personally, I also felt a certain sense of historical \ responsibility. In 500 years, a FrameMaker or Microsoft Word binary document \ will most likely be completely useless. The applications will long since \ have vanished, along with any hardware that could run them, and most likely \ even the basic concepts of \"computer\" and \"application software\" will be \ unrecognizable. However, it is fairly safe to assume that the English \ language will still exist, and I would give even odds that ASCII will still \ be used at some level to encode it. Unlike specific binary file formats, \ ASCII has an air of permanence to it.\ \>", "Text"], Cell["\<\ In versions before V3.0, we used an 8-bit ASCII format, while in \ V3.0 we have switched to a pure 7-bit ASCII format. There are, however, \ other much larger changes in the file format in V3.0.\ \>", "Text"], Cell[TextData[{ "Starting with the first pre-release version of ", StyleBox["Mathematica", FontSlant->"Italic"], ", the Notebook file format was a very simple, perhaps simplistic, text \ format. Each cell was delimited by a line starting with ", StyleBox["\":[\"", "Output"], ", and contained a series of badly named tokens representing option \ settings. Suffice to say that the format did not have room to grow." }], "Text"], Cell[TextData[{ "In V3.0, we switched to using ", StyleBox["Mathematica", FontSlant->"Italic"], " syntax to represent notebooks. A notebook is simply a list of ", StyleBox["Cell[]", "Input"], " objects (described above). A notebook containing two cells might look \ like this:" }], "Text"], Cell[BoxData[ \(Notebook[{\n\t\tCell["This is the first cell.", "Text"], \n\t\t Cell["This is the second cell.", "Text"]\n}]\)], "Input"], Cell[TextData[{ "Those who have access to V3.0 may want to take a look at an actual \ notebook document at this point. Use any text editor other than ", StyleBox["Mathematica", FontSlant->"Italic"], " to open a file containing a few cells (BBEdit, Notepad, vi, emacs, \ Microsoft Word, etc, will work fine). You will see about a screen full of \ general comments intended for people who happen upon the file in email, \ followed by the main ", StyleBox["Notebook[]", "Input"], " expression." }], "Text"], Cell[TextData[{ "The ", StyleBox["Mathematica", FontSlant->"Italic"], " expression format allows for a great deal of flexibility, within a well \ defined language environment. It also means notebook documents can be loaded \ into the kernel, processed, and written back out again, using ordinary ", StyleBox["Mathematica", FontSlant->"Italic"], " commands like ", StyleBox["Put", "Input"], " and ", StyleBox["Get", "Input"], "." }], "Text"], Cell[TextData[{ "The biggest problem with this format is common to any linear, sequential \ text format: efficiency. Once you have a notebook document larger than a few \ pages, it is unacceptably slow to read in the entire contents of the file \ each time it is opened. This is especially true if the document contains \ complex mathematical expressions, or large PostScript graphics. For \ acceptable performance, it is necessary to load only those portions of the \ file that are actually needed to display the currently visible range of the \ document. If the user jumps to the end of the document, the program needs a \ way to load the cells at the end ", StyleBox["without", FontSlant->"Italic"], " loading all the cells in between." }], "Text"], Cell[TextData[{ "This is only possible if some additional information is maintained in the \ file, basically meta-information about the layout of the main linear \ sequence. The solution I chose for V3.0 was to write out a ", StyleBox["comment", FontSlant->"Italic"], " containing another ", StyleBox["Mathematica", FontSlant->"Italic"], " syntax expression that mirrors the main notebook expression, except that \ each ", StyleBox["Cell", "Input"], " object contains only a few numbers giving the byte offsets within the \ file where the actual ", StyleBox["Cell", "Input"], " data is to be found. Here is an example of this comment for the simple \ notebook example above (containing two Text style cells):" }], "Text"], Cell[BoxData[ \( (*NotebookFileOutline\n Notebook[{\nCell[1709, \ 49, \ 39, \ 0, \ 30, \ "Text"], \n Cell[1751, \ 51, \ 40, \ 0, \ 30, \ "Text"]\n}\n]\n*) \)], "Input"], Cell[TextData[{ "This comment contains all the information necessary to locate the two full \ ", StyleBox["Cell", "Input"], " expressions in the main ", StyleBox["Notebook", "Input"], " expression. When the file is opened in the front end, this comment is \ read in its entirety. Then, as the user scrolls around in the docuement, \ this information is used to incrementally load the actual cell data as \ needed." }], "Text"], Cell[TextData[{ "The arguments to ", StyleBox["Cell", "Input"], " in this comment are:" }], "Text"], Cell[BoxData[ RowBox[{"Cell", "[", StyleBox[ "\(byte\\ offset, line\\ number, byte\\ count, line\\ count, \ height\\ estimate, style\\ name, options\)", FontSlant->"Italic"], "]"}]], "Input"], Cell[TextData[{ "The first two numbers say where the ", StyleBox["Cell", "Input"], " expression starts: It is necessary to know the line number (i.e., the \ number of return characters up to this point in the file), because on \ DOS/Windows systems, lines are terminated by two characters \ (return/linefeed), instead of a single character as in the rest of the world. \ If the file is transferred to or from a DOS system, the byte offsets within \ the file will change: By knowing the number of return characters up to each \ offset, this can be adjusted for automatically." }], "Text"], Cell["\<\ The next two numbers specify the number of characters or lines in \ the cell: This allows the data representing a given cell to be shifted around \ in the file using low level file operations. The height estimate allows the \ scroll bar range to be set approximately correctly (the range is the sum of \ the heights of all the cells in the notebook, including those that have never \ been displayed). The estimate will be perfect only when the file is reopened \ on the same system it was saved on, no fonts have been added or removed from \ the system, and the window is not resized after opening.\ \>", "Text"], Cell["\<\ The style name and optional options are used to get the values of \ those few options whose effects are non-local. For example, options that \ effect the automatic grouping behavior of cells must be known for all cells, \ not just those that are currently visible.\ \>", "Text"], Cell[TextData[{ "Following the outline comment are additional comments that allow the front \ end to rapidly locate cells that match a given keyword (", StyleBox["CellTag", "Input"], "). This is currently used only for the Help Browser, but in the future it \ should be useful for other searching/indexing features." }], "Text"], Cell[TextData[{ "Of course, because the file outline comment contains specific character \ offsets, if the file is edited outside of ", StyleBox["Mathematica", FontSlant->"Italic"], " (in a text editor), the offsets will not be correct anymore. This is not \ really a problem, because the front end recognizes that the file has been \ edited, and simply ignores the file outline, reparsing the main ", StyleBox["Notebook", "Input"], " expression." }], "Text"] }, Open ]], Cell[CellGroupData[{ Cell["Cross Platform Compatibility", "Section"], Cell["\<\ There are several separate issues that need to be addressed in \ order to have full, seamless compatibility between different computer \ systems. (As of today, the systems in question are Macintosh, Microsoft \ Windows (Windows 95, OS-2), UNIX (X-Windows), and NeXT.)\ \>", "Text"], Cell[TextData[ "\[Bullet] Graphics formats are different.\n\[Bullet] The line termination \ character is different (return, linefeed, or both).\n\[Bullet] The available \ fonts are different.\n\[Bullet] The character codes used to represent \ accented and special characters are different."], "Text", CellMargins->{{49, Inherited}, {Inherited, Inherited}}], Cell["\<\ In versions before V3.0 we had effectively solved only the first of \ these problems, by including a simple PostScript interpreter as part of the \ front end. This allowed us to use PostScript as a standard that could be \ rendered on all systems. This worked, but could be inefficient because \ PostScript is a very verbose format for representing graphics.\ \>", "Text"], Cell["In V3.0, we solve all these problems quite effectively.", "Text"], Cell["\<\ In addition to supporting PostScript, V3.0 introduces a platform \ independent bitmap format, which allows a compact representation of bitmap \ images, including caches of rendered PostScript images (PostScript can take a \ very long time to render, so a bitmap image of each finished image is stored \ in the notebook file).\ \>", "Text"], Cell["\<\ The line termination problem is solved by the particularly clever \ way we manage our file format: See the File Format section above.\ \>", "Text"], Cell["\<\ The font and character encoding problems are related, and \ difficult. The first 127 character codes that make up the ASCII standard are \ universally compatible, but they include only upper and lower case, \ unaccented roman letters, arabic numerals, and a very small number of \ punctuation marks. Beyond that, there is no standard: Each of the 4 major \ classes of systems uses a different default character encoding for accented \ roman letters, and there are dozens of widely used encodings for non-roman \ character sets (Kanji being the most important example). This very, very \ complex issue cannot be ignored, especially not for a system so heavily \ involved in mathematics, where literally hundreds of special characters are \ used.\ \>", "Text"], Cell["\<\ Attempting to bring some order to this chaos is the Unicode \ character encoding standard. The Unicode consortium has developed a 16-bit \ character encoding that aims to define a single unique code to represent each \ and every character in each and every human language that is or ever has \ been. Needless to say, they will never succeed, but they are making a good \ go at it, and their efforts are, if nothing else, an inspiration.\ \>", "Text"], Cell[TextData[{ StyleBox["Mathematica", FontSlant->"Italic"], " uses the Unicode character encoding internally. Thus, for example, the \ character \[Pi] is represented internally as the code 960, regardless of what \ platform the front end is running on. This uniformity is vital if things \ like this are to work:" }], "Text"], Cell[CellGroupData[{ Cell[BoxData[ \(N[\[Pi]]\)], "Input"], Cell[BoxData[ \(3.14159265358979311`\)], "Output"] }, Open ]], Cell["\<\ Without a uniform internal encoding, getting several hundred \ mathematical symbols to evaluate properly on all platforms would be a \ nightmare.\ \>", "Text"], Cell[TextData[{ "As mentioned earlier, in V3.0 we are using a pure 7-bit ASCII file format \ for notebooks. To represent 16-bit Unicode characters, we could have chosen \ to write them in octal or hexadecimal form. However, while we use Unicode \ internally, we decided that we would ", StyleBox["not", FontSlant->"Italic"], " use it to represent most characters in files." }], "Text"], Cell[TextData[{ "We decided to give unique, english ", StyleBox["names", FontSlant->"Italic"], " to a very large number of characters (almost 800). These names make the \ file much more readable to someone looking at it in a raw text editor, and \ should help to ensure the intelligibility of the file well past the lifetime \ of ", StyleBox["Mathematica", FontSlant->"Italic"], " and Unicode. The character names are similar to ", StyleBox["Mathematica", FontSlant->"Italic"], " function names in that they are long, descriptive, and never \ abbreviated." }], "Text"], Cell[TextData[{ "Character names are written as ", StyleBox["\\[name]", "Output"], ", as in ", StyleBox["\\[\[VeryThinSpace]Pi]", "Output"], " to represent \[Pi]. For example, the following cell:" }], "Text"], Cell[TextData[ "The Weierstrass \[WeierstrassP] function is an interesting function not \ related to Fahrvergn\[UDoubleDot]gen."], "Text", CellMargins->{{49, Inherited}, {Inherited, Inherited}}], Cell["is written in the notebook file as:", "Text"], Cell[BoxData[ \(Cell[ "The Weierstrass \[WeierstrassP] function is an interesting function \ not related to Fahrvergn\[UDoubleDot]gen.", \ "Text"]\)], "Input", ShowSpecialCharacters->False], Cell[TextData[{ "This example contains two special characters. The \[UDoubleDot] character \ is one that is in most platform's (non)-standard character encodings, while \ the \[WeierstrassP] character is available only in a very small number of \ technical fonts, and is not part of ", StyleBox["any", FontSlant->"Italic"], " standard encoding other than Unicode." }], "Text"], Cell["\<\ Although these names may seem like a very wordy way to write out a \ single character, they do ensure absolute compatibility, because they define \ uniquely the character you want, rather than a number that must be \ interpreted in light of an encoding table that you amy not have access to. \ To put it another way, the file is self-contained with regards to character \ representation.\ \>", "Text"], Cell[TextData[{ "Although we have 800 character names, including all the western accented \ characters, and all mathematical and scientific symbols we could identify \ with extensive research, this is still just a small subset of the 60,000-some \ unicode characters. The great bulk of characters we do not have names for \ are the Japanese, Chinese, and Korean pictographs, with a smaller \ contribution from the colorful variety of the world's lanuages (Arabic, \ Hebrew, Tamil, etc). To handle this overwhelming number of characters, we \ use the Unicode character codes to store the characters in notebook files. \ The codes are written in hexadecimal, using the ", StyleBox["Mathematica", FontSlant->"Italic"], " syntax ", StyleBox["\\:xxxx", "Output"], " to represent each 16-bit value. This representation coexists easily with \ the ", StyleBox["\\[name]", "Output"], " notation. If, in the future, it becomes clear that certain characters \ should be given names, they can be added without any loss of backwards \ compatibility." }], "Text"], Cell[TextData[{ "Having solved the problem of representing characters in a highly \ compatible cross-platform way, there remains the serious ", StyleBox["font", FontSlant->"Italic"], " problem. It does little good to have a way of representing \ \[WeierstrassP], or \[Aleph], or \[Gimel], or \[HBar], if you don't have a \ font to draw them with. After considerable discussion and research, we \ decided that there simply did not exist a coherent, universal, family of \ fonts to represent the characters commonly used in all the fields in which ", StyleBox["Mathematica", FontSlant->"Italic"], " is used." }], "Text"], Cell["\<\ So, we created a family of over 600 mathematical, scientific, and \ other special characters, in roman, bold, italic, proportional and \ mono-spaced versions. The mono-spaced characters are particularly \ interesting: No one has ever attempted to make such a complete set of \ mono-spaced special characters (mainly because no one had any reason \ to).\ \>", "Text"], Cell[TextData[{ "In the past, output from ", StyleBox["Mathematica", FontSlant->"Italic"], " had to be displayed in a monospaced font for technical reasons: This is \ no longer the case, and we had initially thought that proportionally spaced \ fonts would be the automatic choice now that the technical limitation had \ been removed. However, we found that for good readability on screen, \ Courier-like, monospaced characters were considerably superior to any \ proportionally spaced font. So, the default output format type \ (StandardForm) uses Courier and the monospaced version of our fonts for \ everything except certain characters (large brackets, integral signs, certain \ infix operators, etc)." }], "Text"], Cell[TextData[{ "Because out family of fonts is a standard part of ", StyleBox["Mathematica", FontSlant->"Italic"], " V3.0, and available on all platforms, it is possible to transfer \ notebooks containing very complex mathematical typesetting with complete \ compatibilty. There is literally no other system that is able to do this for \ more than a very restricted set of characters, or a limited number of \ platforms." }], "Text"] }, Open ]], Cell[CellGroupData[{ Cell["Integration with the Kernel", "Section"], Cell[TextData[{ "The front end and kernel have always been completely separate programs, \ connected only by a single bi-directional data stream. Initially we used a \ primitive protocal known internally as Math Talk. Later this was replaced \ with ", StyleBox["MathLink", FontSlant->"Italic"], ", which is a more sophisticated, general way of transmitting arbitrary ", StyleBox["Mathematica", FontSlant->"Italic"], " expressions across data streams. (The ", StyleBox["MathLink", FontSlant->"Italic"], " protocol has been published, and libraries are available for those who \ want to write their own programs using it.)" }], "Text"], Cell["\<\ This strict separation has many advantages. It allows a front end \ running on one computer to connect to one or more kernels running on \ different computers, even different types of computers. A typical case would \ be a front end running on a small desktop machine with a good user interface \ (e.g. a Macintosh), connected to a kernel running on a fast, physically \ distant computer with little or no user interface (e.g. a mainframe, or high \ end workstation server).\ \>", "Text"], Cell[TextData[{ "Initially, the operation of the front end did not depend in any way on the \ kernel. Unless you actually wanted to evaluate a ", StyleBox["Mathematica", FontSlant->"Italic"], " expression, the front end had no use for the kernel. Over time, more and \ more features in the front end have come to rely on the presence of a \ kernel." }], "Text"], Cell["\<\ The first feature that required a kernel was command completion. \ It works by sending the partially entered function name to the kernel, and \ receiving a list of possible completions. Since this information exists only \ in the kernel (and may change if the user defines new symbols), this is \ clearly necessary.\ \>", "Text"], Cell[TextData[{ "Next, the Function Browser was implemented by using the kernel to get \ usage messages for function names, and lists of functions defined in \ currently loaded packages. In a slight twist, the V3.0 feature, now called \ the Help Browser, does not use the kernel any more. It has direct access to \ the full text of the ", StyleBox["Mathematica", FontSlant->"Italic"], " book, which is much more complete than the usage messages available in \ the kernel." }], "Text"], Cell[TextData[{ "With V3.0, two standard menu commands, Convert to TeX and Convert to HTML, \ are implemented entirely in the kernel. The front end simply tells the \ kernel what the user wants, and the kernel reads the front-most notebook \ across the ", StyleBox["MathLink", FontSlant->"Italic"], " connection, asks the front end to put up a Save-As dialog to get a file \ name, then does the conversion." }], "Text"], Cell["\<\ The palette mechanism also makes use of the kernel to execute \ button action functions, when required. Many simple action functions can be \ executed directly in the front end (paste text, evaluate selection, change \ attributes, move selection, open/close files, are some of the operations that \ can be executed directly in the front end). However, any action functions \ that required testing conditions or doing computations of any sort must be \ evaluated in the kernel.\ \>", "Text"], Cell["\<\ In the future, it is likely that more and more features in the \ front end will come to rely on a kernel. The main force limiting this trend \ is the large amount of memory required to run a kernel. As of today, it \ would be unacceptable to require a kernel for the front end to operate at \ all. However, the day is not too far off when this will be reasonable. At \ this point, the front end will probably incorporate its own personal kernel, \ which it will use to coordinate many internal operations, allowing for a \ great deal of flexibility and user programmability.\ \>", "Text"] }, Open ]], Cell[CellGroupData[{ Cell["Cross Platform Code Sharing", "Section"], Cell["\<\ As discussed above, the front end and kernel are completely \ separate programs. The original motivation for this architecture was not the \ advantage of allowing them to run on separate computers. Instead, the idea \ was that the kernel would be a purely platform independent program, while the \ front end would encapsulate all the messy platform dependent interactions \ with particular window systems.\ \>", "Text"], Cell["\<\ The kernel was to be a pure, text-in-text-out program that would be \ compiled from almost identical sources on all platforms. The front end, we \ thought, would be a relatively small, disposable piece of code that would be \ written from scratch for each different window system.\ \>", "Text"], Cell["\<\ The kernel was originally developed on UNIX systems, and it clearly \ shows this bias. It does, in fact, run almost identically on all platforms, \ but only because it turns out that all platforms implement UNIX compatibility \ libraries. So, this part of the original plan has worked out pretty much as \ expected, mainly by luck.\ \>", "Text"], Cell["\<\ The front end part of the plan turned out to be completely \ mistaken. There were two basic errors in our thinking: First, the front end \ is a much larger and more sophisticated program than we thought. Second, \ window systems have a lot more in common than we thought.\ \>", "Text"], Cell[TextData[{ "I originally wrote the front end as a Macintosh only program, with no \ thought what so ever to porting it to any other system. When Steve Jobs was \ developing his NeXT computer, he learned about ", StyleBox["Mathematica", FontSlant->"Italic"], ", and Wolfram Research ended up making a deal to bundle ", StyleBox["Mathematica", FontSlant->"Italic"], " with all NeXT systems." }], "Text"] }, Open ]], Cell[CellGroupData[{ Cell["Menus", "Section"], Cell["\<\ The earliest, Macintosh-only, version of the front end did not \ allow any rearrangement of menu commands: The function of each item was \ determined by its position within the menu.\ \>", "Text"], Cell["\<\ With the first cross-platform version of the front end \ (Macintosh-NeXT), it was necessary to introduce a more flexible way of \ associating items in menus with their corresponding functions. Each internal \ function was assigned a unique number that did not change regardless of which \ menu or position an item was in. In theory, this allowed users to rearrange \ menus at will, but because the menu layout was stored using platform specific \ system formats (MENU resources and nib files), this was not practical for \ most users.\ \>", "Text"], Cell[TextData[{ "In V3.0, each internal function has been given a name instead of just a \ number, and the layout of the menus is defined by a ", StyleBox["Mathematica", FontSlant->"Italic"], " expression format text file. The format of the file allows it to be \ edited fairly easily by someone familiar with the ", StyleBox["Mathematica", FontSlant->"Italic"], " language, and perhaps more importantly allows it to be manipulated by ", StyleBox["Mathematica", FontSlant->"Italic"], " programs." }], "Text"], Cell[TextData[{ "The file containing the menu layout is called ", StyleBox["MenuSetup.tr", "Output"], ", A separate copy for each platform is in the main ", StyleBox["Mathematica", FontSlant->"Italic"], " installation directory, inside ", StyleBox["SystemFiles/FrontEnd/TextResources/", "Output"], StyleBox["platform", "Output", FontSlant->"Italic"], ", where platform is one of ", StyleBox["Macintosh", "Output"], ", ", StyleBox["NeXT", "Output"], ", ", StyleBox["X", "Output"], ", or ", StyleBox["Windows", "Output"], ". The file contains a nested set of ", StyleBox["Menu[]", "Input"], " and ", StyleBox["Item[]", "Input"], " expressions: Here is the beginning of the file for the X version:" }], "Text"], Cell[BoxData[ \(\(Menu["Menu for the X Front End", \n{\n\tMenu["File", \ \n \t{\n\t\tItem["New", \ "New", MenuKey["n", \ Modifiers -> {Command}]], \n\t\t Item["Open...", \ "Open", MenuKey["o", \ Modifiers -> {Command}]], \n\t\t Item["Close", \ "Close", MenuKey["w", \ Modifiers -> {Command}]], \n\t\tItem["Save", \ "Save", MenuKey["s", \ Modifiers -> {Command}]], \n\t\t Item["Save As...", \ "SaveRename", MenuKey["S", \ Modifiers -> {Command, \ Shift}]], \n\t\t Menu["Save As Special...", \n \t\t{\n\t\t\t Item["Pre-3.0 Notebook", SaveRenameSpecial["V20Notebook"]], \n \t\t\tItem["Text", \ SaveRenameSpecial["Text"]], \n\t\t\t Item["Cell Expression", SaveRenameSpecial["CellExpression"]], \n\t\t\tItem["Notebook Expression", SaveRenameSpecial["NotebookExpression"]], \n\t\t\t Item["Package Format", SaveRenameSpecial["Package"]], \n\t\t\t Delimiter, \n\t\t\t Item["TeX", \ \n\t\t\t\t FrontEndExecute[ToExpression["FrontEnd`DoTeXSave[]"]], \n \t\t\t\tMenuEvaluator -> Automatic], \n\t\t\t Item["HTML", \ \n\t\t\t\t FrontEndExecute[ToExpression["FrontEnd`DoHTMLSave[]"]], \n \t\t\t\tMenuEvaluator -> Automatic]\n\t\t}], \n\t\t\n\t\t \(etc.\)\)\)], "Input", FontWeight->"Plain"], Cell[TextData[{ "This defines the File menu, with its \"Save As Special...\" submenu. The \ first argument to ", StyleBox["Item", "Input"], " is the text to be displayed in the menu. The second argument is the \ token that uniquely identifies the function carried out by the menu item. \ Notice that some of the items specify command key equivalents using the \ optional third argument." }], "Text"], Cell[TextData[{ "Two items at the end demonstrate that the second argument can also be a \ function to be executed in the front end, or evaluated in the kernel. Menus \ handle their action functions in the same way ", StyleBox["ButtonBox", "Input"], " objects do, with the same set of available functions (documented in the ", StyleBox["Mathematica", FontSlant->"Italic"], " book, and online documentation)." }], "Text"] }, Open ]], Cell[CellGroupData[{ Cell["Conclusion", "Section"], Cell[TextData[{ "There have been three major trends in the developement of the ", StyleBox["Mathematica", FontSlant->"Italic"], " front end over its 9 year life." }], "Text"] }, Open ]] }, Open ]] }, FrontEndVersion->"Macintosh 3.0", ScreenRectangle->{{0, 640}, {0, 460}}, WindowToolbars->{}, WindowSize->{631, 436}, WindowMargins->{{4, Automatic}, {Automatic, 1}}, Magnification->1, MacintoshSystemPageSetup->"\<\ 00<0001804P000000]X2:?oQon82n@960dL5:0?l0080001804P000000]X2:001 0000I00000400@4100000BL?00400@00000000000000000201T1T0000000@000 00000000004000000000000000000000\>" ] (*********************************************************************** Cached data follows. If you edit this Notebook file directly, not using Mathematica, you must remove the line containing CacheID at the top of the file. The cache data will then be recreated when you save this file from within Mathematica. ***********************************************************************) (*CellTagsOutline CellTagsIndex->{} *) (*CellTagsIndex CellTagsIndex->{} *) (*NotebookFileOutline Notebook[{ Cell[CellGroupData[{ Cell[1731, 51, 39, 0, 98, "Title"], Cell[1773, 53, 77, 0, 47, "Subsubtitle"], Cell[CellGroupData[{ Cell[1875, 57, 41, 0, 44, "Subsection"], Cell[1919, 59, 260, 7, 47, "Text"], Cell[2182, 68, 574, 11, 95, "Text"], Cell[2759, 81, 370, 6, 62, "Text"], Cell[3132, 89, 177, 4, 46, "Text"] }, Open ]], Cell[CellGroupData[{ Cell[3346, 98, 24, 0, 50, "Section"], Cell[3373, 100, 384, 8, 63, "Text"], Cell[3760, 110, 44, 0, 30, "Text"], Cell[3807, 112, 323, 5, 46, "Text"], Cell[4133, 119, 329, 5, 62, "Text"], Cell[4465, 126, 333, 6, 62, "Text"], Cell[4801, 134, 553, 10, 79, "Text"], Cell[5357, 146, 576, 11, 95, "Text"], Cell[5936, 159, 5997, 292, 121, "Text"] }, Open ]], Cell[CellGroupData[{ Cell[11970, 456, 40, 0, 50, "Section"], Cell[12013, 458, 343, 8, 63, "Text"], Cell[12359, 468, 396, 7, 78, "Text"], Cell[12758, 477, 253, 5, 46, "Text"], Cell[13014, 484, 309, 7, 48, "Text"], Cell[13326, 493, 364, 12, 56, "Input"], Cell[13693, 507, 413, 8, 63, "Text"], Cell[14109, 517, 286, 7, 48, "Text"], Cell[14398, 526, 77, 1, 26, "Input"], Cell[14478, 529, 206, 6, 47, "Text"], Cell[14687, 537, 295, 6, 116, "Input"] }, Open ]], Cell[CellGroupData[{ Cell[15019, 548, 30, 0, 50, "Section"], Cell[15052, 550, 143, 3, 30, "Text"], Cell[15198, 555, 340, 6, 62, "Text"], Cell[15541, 563, 395, 7, 62, "Text"], Cell[15939, 572, 589, 9, 94, "Text"], Cell[16531, 583, 298, 5, 62, "Text"], Cell[16832, 590, 367, 6, 62, "Text"], Cell[17202, 598, 442, 7, 78, "Text"], Cell[17647, 607, 584, 9, 94, "Text"], Cell[18234, 618, 448, 7, 78, "Text"], Cell[18685, 627, 750, 13, 111, "Text"], Cell[19438, 642, 657, 10, 110, "Text"], Cell[20098, 654, 219, 4, 46, "Text"], Cell[20320, 660, 442, 9, 64, "Text"], Cell[20765, 671, 305, 8, 47, "Text"], Cell[21073, 681, 149, 2, 71, "Input"], Cell[21225, 685, 519, 11, 80, "Text"], Cell[21747, 698, 467, 14, 65, "Text"], Cell[22217, 714, 765, 13, 111, "Text"], Cell[22985, 729, 749, 17, 97, "Text"], Cell[23737, 748, 188, 3, 116, "Input"], Cell[23928, 753, 438, 10, 63, "Text"], Cell[24369, 765, 105, 4, 31, "Text"], Cell[24477, 771, 226, 5, 41, "Input"], Cell[24706, 778, 594, 10, 95, "Text"], Cell[25303, 790, 624, 9, 94, "Text"], Cell[25930, 801, 289, 5, 62, "Text"], Cell[26222, 808, 335, 6, 63, "Text"], Cell[26560, 816, 474, 10, 81, "Text"] }, Open ]], Cell[CellGroupData[{ Cell[27071, 831, 47, 0, 50, "Section"], Cell[27121, 833, 292, 5, 62, "Text"], Cell[27416, 840, 358, 5, 78, "Text"], Cell[27777, 847, 384, 6, 62, "Text"], Cell[28164, 855, 71, 0, 30, "Text"], Cell[28238, 857, 349, 6, 62, "Text"], Cell[28590, 865, 157, 3, 46, "Text"], Cell[28750, 870, 771, 12, 126, "Text"], Cell[29524, 884, 462, 7, 78, "Text"], Cell[29989, 893, 337, 7, 63, "Text"], Cell[CellGroupData[{ Cell[30351, 904, 41, 1, 26, "Input"], Cell[30395, 907, 54, 1, 26, "Output"] }, Open ]], Cell[30464, 911, 169, 4, 46, "Text"], Cell[30636, 917, 397, 8, 63, "Text"], Cell[31036, 927, 596, 15, 80, "Text"], Cell[31635, 944, 219, 6, 31, "Text"], Cell[31857, 952, 196, 3, 30, "Text"], Cell[32056, 957, 51, 0, 30, "Text"], Cell[32110, 959, 201, 4, 56, "Input"], Cell[32314, 965, 387, 8, 63, "Text"], Cell[32704, 975, 412, 7, 78, "Text"], Cell[33119, 984, 1072, 20, 144, "Text"], Cell[34194, 1006, 638, 13, 80, "Text"], Cell[34835, 1021, 377, 7, 62, "Text"], Cell[35215, 1030, 730, 13, 111, "Text"], Cell[35948, 1045, 445, 9, 63, "Text"] }, Open ]], Cell[CellGroupData[{ Cell[36430, 1059, 46, 0, 50, "Section"], Cell[36479, 1061, 662, 15, 97, "Text"], Cell[37144, 1078, 500, 8, 78, "Text"], Cell[37647, 1088, 373, 8, 63, "Text"], Cell[38023, 1098, 341, 6, 62, "Text"], Cell[38367, 1106, 496, 10, 79, "Text"], Cell[38866, 1118, 430, 9, 63, "Text"], Cell[39299, 1129, 502, 8, 78, "Text"], Cell[39804, 1139, 602, 9, 94, "Text"] }, Open ]], Cell[CellGroupData[{ Cell[40443, 1153, 46, 0, 50, "Section"], Cell[40492, 1155, 431, 7, 78, "Text"], Cell[40926, 1164, 305, 5, 62, "Text"], Cell[41234, 1171, 357, 6, 62, "Text"], Cell[41594, 1179, 297, 5, 62, "Text"], Cell[41894, 1186, 425, 10, 64, "Text"] }, Open ]], Cell[CellGroupData[{ Cell[42356, 1201, 24, 0, 50, "Section"], Cell[42383, 1203, 206, 4, 46, "Text"], Cell[42592, 1209, 560, 9, 94, "Text"], Cell[43155, 1220, 535, 13, 80, "Text"], Cell[43693, 1235, 757, 23, 81, "Text"], Cell[44453, 1260, 1566, 28, 416, "Input"], Cell[46022, 1290, 408, 8, 63, "Text"], Cell[46433, 1300, 438, 10, 64, "Text"] }, Open ]], Cell[CellGroupData[{ Cell[46908, 1315, 29, 0, 50, "Section"], Cell[46940, 1317, 184, 5, 31, "Text"] }, Open ]] }, Open ]] } ] *) (*********************************************************************** End of Mathematica Notebook file. ***********************************************************************)