(************** Content-type: application/mathematica ************** CreatedBy='Mathematica 5.2' Mathematica-Compatible Notebook This notebook can be used with any Mathematica-compatible application, such as Mathematica, MathReader or Publicon. The data for the notebook starts with the line containing 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[ 88571, 2731]*) (*NotebookOutlinePosition[ 90143, 2777]*) (* CellTagsIndexPosition[ 90011, 2770]*) (*WindowFrame->Normal*) Notebook[{ Cell[CellGroupData[{ Cell[TextData[{ "Mathematical Issues of ", StyleBox["Mathematica", FontSlant->"Italic"], "'s BigFloat and Our Resolutions in SNAP Package" }], "Title"], Cell["Kosaku Nagasaka", "Author"], Cell["\<\ Kobe University, Japan nagasaka@main.h.kobe-u.ac.jp\ \>", "TextAboutAuthor"], Cell[TextData[{ "We report the main purpose of the ", StyleBox["Mathematica", FontSlant->"Italic"], "'s precision and accuracy tracking system (", StyleBox["Mathematica", FontSlant->"Italic"], "'s arbitrary precision numbers) according to the official documents and \ the paper by Sofroniou and Spaletta, differences between these informations \ and the actual behaviors of ", StyleBox["Mathematica", FontSlant->"Italic"], ", and the resolutions for this problem in SNAP package. Briefly, this \ presentation follows the ", StyleBox["Mathematica", FontSlant->"Italic"], " book, the ", StyleBox["Mathematica", FontSlant->"Italic"], " guide book for numerics and the paper by Sofroniou and Spaletta [SS05] \ and claims differences from the actual behaviors from the mathematical point \ of view (not the numerical analysis way)." }], "Abstract"], Cell[CellGroupData[{ Cell["Introduction", "SectionFirst"], Cell[TextData[{ "We have been developing SNAP (Symbolic Numeric Algebra for Polynomials) \ package for ", StyleBox["Mathematica", FontSlant->"Italic"], " (see the notebook for International ", StyleBox["Mathematica", FontSlant->"Italic"], " Symposium 2005), providing various functions for symbolic-numeric \ computations: computing approximate GCDs, bounding numerical zeros of \ univariate polynomials, testing irreducibilities of multivariate polynomials, \ computing separation bounds (or irreducibility radii) of bivariate \ polynomials and so on. One of the purposes of the package is giving an \ easy-to-use environment for symbolic-numeric computations, especially for \ people who are not specialists in that subject. The details of the package \ are given in the later section. In the package, all the polynomials with \ numerical errors on their coefficients, are treated as polynomial sets, and \ the author had tried to implement most of functions guarantee that their \ results are mathematically correct. However, recently, according to \ discussions with Wolfram Research Inc., its own precision and accuracy \ tracking system (", StyleBox["Mathematica", FontSlant->"Italic"], "'s arbitrary precision numbers) does not guarantee that the results are \ mathematically accurate so we began to think that the package had to be \ modified fundamentally. ", StyleBox["Mathematica", FontSlant->"Italic"], " only guarantees the first order estimation of numerical errors, according \ to the paper by Sofroniou and Spaletta [SS05] which is the only one we can \ know the system of precision and accuracy in ", StyleBox["Mathematica", FontSlant->"Italic"], " except for other official documents including the ", StyleBox["Mathematica", FontSlant->"Italic"], " guide book by Trott [Trott05]. The details are given in the next section. \ We note that it is a tracking system so guaranteeing only the first order \ terms does not mean any defect of ", StyleBox["Mathematica", FontSlant->"Italic"], "." }], "Text"], Cell["\<\ We note that this research is partly helped by Grants-in-Aid for \ Scientific Research, Ministry of Education, Culture, Sports, Science and \ Technology, JAPAN, #16700016.\ \>", "Text"] }, Open ]], Cell[CellGroupData[{ Cell["Official Behaviors", "Section"], Cell[TextData[{ "In this section, we review the documented official behaviors of ", StyleBox["Mathematica", FontSlant->"Italic"], "'s big floating numbers (arbitrary precision numbers) according to the ", StyleBox["Mathematica", FontSlant->"Italic"], " book, the ", StyleBox["Mathematica", FontSlant->"Italic"], " guide book for numerics [Trott05] and the academic paper by Sofroniou and \ Spaletta [SS05]." }], "Text"], Cell[CellGroupData[{ Cell[TextData[{ "The ", StyleBox["Mathematica", FontSlant->"Italic"], " Book" }], "Subsection"], Cell[TextData[{ "Fundamental informations can be found in the section ", ButtonBox["3.1.4", ButtonStyle->"MainBookLink"], ", ", ButtonBox["3.1.5", ButtonStyle->"MainBookLink"], " and ", ButtonBox["3.1.6", ButtonStyle->"MainBookLink"], " in the ", StyleBox["Mathematica", FontSlant->"Italic"], " book. There are two ways operating with floating point numbers, arbitrary \ precision and machine precision numbers. We focus on the arbitrary precision \ numbers only since the machine precision numbers do not have significant \ precision and accuracy informations." }], "Text"], Cell[TextData[{ "To make sure, we note that any floating point numbers without explicit \ precision or accuracy specifications are treated as machine precision numbers \ in ", StyleBox["Mathematica", FontSlant->"Italic"], " and most of facts argued in the below are not correct for machine \ precision numbers." }], "Text"], Cell[CellGroupData[{ Cell["Precision and Accuracy", "Subsubsection"], Cell[TextData[{ "We can find the following definitions of precision and accuracy in terms \ of uncertainty ", Cell[BoxData[ \(TraditionalForm\`\[Delta]\)]], " of the given number ", Cell[BoxData[ \(TraditionalForm\`x\)]], ", in the ", StyleBox["Mathematica", FontSlant->"Italic"], " book." }], "Text"], Cell[TextData[{ " In general, the ", StyleBox["precision", "TI"], " of an approximate real number is the effective number of decimal digits \ in it which are treated as significant for computations. The ", StyleBox["accuracy", "TI"], " is the effective number of these digits which appear to the right of the \ decimal point. Note that to achieve full consistency in the treatment of \ numbers, precision and accuracy often have values that do not correspond to \ integer numbers of digits. " }], "Text", CellMargins->{{54, Inherited}, {Inherited, Inherited}}, Background->GrayLevel[0.900008]], Cell[TextData[{ StyleBox["Mathematica", "TI"], " is set up so that if a number ", Cell[BoxData[ FormBox[ StyleBox["x", "TI"], TraditionalForm]], "InlineFormula"], " has uncertainty ", Cell[BoxData[ \(TraditionalForm\`\[Delta]\)], "InlineFormula"], ", then its true value can lie anywhere in an interval of size ", Cell[BoxData[ \(TraditionalForm\`\[Delta]\)], "InlineFormula"], " from ", Cell[BoxData[ FormBox[ RowBox[{ StyleBox["x", "TI"], "-", "\[Delta]", "/", "2"}], TraditionalForm]], "InlineFormula"], " to ", Cell[BoxData[ FormBox[ RowBox[{ StyleBox["x", "TI"], "+", "\[Delta]", "/", "2"}], TraditionalForm]], "InlineFormula"], ". An approximate number with accuracy ", Cell[BoxData[ FormBox[ StyleBox["a", "TI"], TraditionalForm]], "InlineFormula"], " is defined to have uncertainty ", Cell[BoxData[ FormBox[ SuperscriptBox["10", RowBox[{"-", StyleBox["a", "TI"]}]], TraditionalForm]], "InlineFormula"], ", while a non\[Hyphen]zero approximate number with precision ", Cell[BoxData[ FormBox[ StyleBox["p", "TI"], TraditionalForm]], "InlineFormula"], " is defined to have uncertainty ", Cell[BoxData[ FormBox[ RowBox[{"\[VerticalSeparator]", StyleBox["x", "TI"], "\[VerticalSeparator]", SuperscriptBox["10", RowBox[{"-", StyleBox["p", "TI"]}]]}], TraditionalForm]], "InlineFormula"], ". " }], "Text", CellMargins->{{54, Inherited}, {Inherited, Inherited}}, Background->GrayLevel[0.900008]], Cell[BoxData[GridBox[{ {\(Precision[x]\), Cell[TextData[Cell[BoxData[ \(TraditionalForm\`\(-\(\(log\_10\)(\(\(\[Delta]\)\(/\)\) | x | )\)\)\)]]]]}, {\(Accuracy[x]\), Cell[TextData[Cell[BoxData[ \(TraditionalForm\`\(-\(\(log\_10\)(\[Delta])\)\)\)]]]]} }]], "InputOnly", Background->GrayLevel[0.900008]], Cell["\<\ Definitions of precision and accuracy in terms of uncertainty. \ \ \>", "Caption", Background->GrayLevel[0.900008]], Cell[TextData[{ "Hence, we have the following mathematical facts for the ", StyleBox["Mathematica", FontSlant->"Italic"], "'s arbitrary precision number ", Cell[BoxData[ \(TraditionalForm\`x\)]], " and its true value ", Cell[BoxData[ \(TraditionalForm\`x\&_\)]], " where ", Cell[BoxData[ \(TraditionalForm\`p(x)\)]], " and ", Cell[BoxData[ \(TraditionalForm\`a(x)\)]], " denote precision and accuracy of ", Cell[BoxData[ \(TraditionalForm\`x\)]], ", respectively, if ", Cell[BoxData[ \(TraditionalForm\`x \[NotEqual] 0\)]], ". Moreover, we may suppose, expect or think that the mathematical correct \ value is included in the set after calculations though this article reports \ that this expectation is not satisfied by ", StyleBox["Mathematica", FontSlant->"Italic"], " unfortunately." }], "Text"], Cell[BoxData[ RowBox[{\(x\&_\), "\[Element]", RowBox[{ StyleBox["{", SpanMaxSize->Infinity], RowBox[{\(x\&~\), " ", StyleBox["|", SpanMaxSize->Infinity], " ", \(\(\(|\)\(x - x\&~\)\(|\)\)\/\(\(|\)\(x\)\(|\)\) \[LessEqual] 10\^\(\(-p\) \((x)\)\)\/2\)}], StyleBox["}", SpanMaxSize->Infinity]}]}]], "NumberedEquation"], Cell[BoxData[ RowBox[{\(x\&_\), "\[Element]", RowBox[{ StyleBox["{", SpanMaxSize->Infinity], RowBox[{\(x\&~\), " ", StyleBox["|", SpanMaxSize->Infinity], " ", StyleBox["|", SpanMaxSize->1], \(x - x\&~\), StyleBox["|", SpanMaxSize-> 1], \(\(\[LessEqual]\)\(10\^\(\(-a\) \((x)\)\)\/2\)\)}], StyleBox["}", SpanMaxSize->Infinity]}]}]], "NumberedEquation"], Cell[TextData[{ "In ", StyleBox["Mathematica", FontSlant->"Italic"], ", built-in functions: ", ButtonBox["Precision", ButtonStyle->"RefGuideLink"], ", ", ButtonBox["Accuracy", ButtonStyle->"RefGuideLink"], ", ", ButtonBox["SetPrecision", ButtonStyle->"RefGuideLink"], " and ", ButtonBox["SetAccuracy", ButtonStyle->"RefGuideLink"], " are designed for operating the above precision and accuracy. We give some \ examples of these functions." }], "Text"], Cell[CellGroupData[{ Cell[BoxData[ \(\(\(x\)\(=\)\(SetPrecision[2, 20]\)\(\ \)\( (*\ equivalent\ to\ 2`20\ *) \)\)\)], "Input", CellLabel->"In[4]:="], Cell[BoxData[ \(2.`20. \)], "Output", CellLabel->"Out[4]="] }, Open ]], Cell[CellGroupData[{ Cell[BoxData[ \(\(\(y\)\(=\)\(SetAccuracy[2, 20]\)\(\ \)\( (*\ equivalent\ to\ 2``20\ *) \)\)\)], "Input", CellLabel->"In[5]:="], Cell[BoxData[ \(2.`20.30102999566398\)], "Output", CellLabel->"Out[5]="] }, Open ]], Cell[CellGroupData[{ Cell[BoxData[ \({Precision[x], \ Accuracy[x]}\)], "Input", CellLabel->"In[6]:="], Cell[BoxData[ \({20.`, 19.69897000433602`}\)], "Output", CellLabel->"Out[6]="] }, Open ]], Cell[CellGroupData[{ Cell[BoxData[ \({Precision[y], \ Accuracy[y]}\)], "Input", CellLabel->"In[7]:="], Cell[BoxData[ \({20.30102999566398`, 20.`}\)], "Output", CellLabel->"Out[7]="] }, Open ]] }, Open ]], Cell[CellGroupData[{ Cell["Error Tracking System", "Subsubsection"], Cell[TextData[{ StyleBox["Mathematica", FontSlant->"Italic"], "'s precision and accuracy tracking system is one of important features of \ ", StyleBox["Mathematica", FontSlant->"Italic"], ". So, what is the tracking system? For this question, we can find the \ following paragraph in the section ", ButtonBox["3.1.5", ButtonStyle->"MainBookLink"], " in the ", StyleBox["Mathematica", FontSlant->"Italic"], " book. " }], "Text"], Cell[TextData[{ "When you do a computation, ", StyleBox["Mathematica", "TI"], " keeps track of which digits in your result could be affected by unknown \ digits in your input. It sets the precision of your result so that no \ affected digits are ever included. This procedure ensures that all digits \ returned by ", StyleBox["Mathematica", "TI"], " are correct, whatever the values of the unknown digits may be. " }], "Text", CellMargins->{{54, Inherited}, {Inherited, Inherited}}, Background->GrayLevel[0.900008]], Cell[TextData[{ "By the above official document, most of users, especially beginners tend \ to believe that all significant digits computed by ", StyleBox["Mathematica", FontSlant->"Italic"], " are mathematically correct. However, this is not true and some actual \ evidences are shown in the later section." }], "Text"] }, Open ]], Cell[CellGroupData[{ Cell["Converting to Arbitrary Precision Numbers", "Subsubsection"], Cell[TextData[{ "We can not neglect representing errors when we use floating-point numbers. \ However, the ", StyleBox["Mathematica", FontSlant->"Italic"], " book does not have any informations about this big problem. For example, \ we can not represent ", Cell[BoxData[ \(TraditionalForm\`0.1\)]], " in base 2 with any finite precision since it is a repeating fractional \ number. For those numbers, the system have to round them up. If we use \ machine precision numbers, the specification of this rounding is defined as a \ part of IEEE754 and ", StyleBox["Mathematica", FontSlant->"Italic"], " also obeys this standard." }], "Text"] }, Open ]] }, Open ]], Cell[CellGroupData[{ Cell[TextData[{ "The ", StyleBox["Mathematica", FontSlant->"Italic"], " Guide Book and The Academic Paper" }], "Subsection"], Cell[TextData[{ "We have to read the ", StyleBox["Mathematica", FontSlant->"Italic"], " guide book and the academic paper if we want to know the mechanism of \ arbitrary precision numbers more. In the ", StyleBox["Mathematica", FontSlant->"Italic"], " guide book for numerics, we can find more detailed informations in the \ section 1.1.1 (Numbers with an Arbitrary Number of Digits). More mathematical \ informations can be found in the following two academic papers: one is by \ Sofroniou and Spaletta [SS05] and the other is by Fateman [Fateman92]." }], "Text"], Cell[CellGroupData[{ Cell["Precision and Accuracy", "Subsubsection"], Cell[TextData[{ "We can find the following argument in the ", StyleBox["Mathematica", FontSlant->"Italic"], " guide book for numerics. This is the same definition of the ", StyleBox["Mathematica", FontSlant->"Italic"], " book. However, there is an author's comment (red colored words)." }], "Text"], Cell[TextData[{ "Reverting these definitions, we can say that a number ", Cell[BoxData[ \(TraditionalForm\`z\)]], " with accuracy ", Cell[BoxData[ \(TraditionalForm\`a\)]], " and precision ", Cell[BoxData[ \(TraditionalForm\`p\)]], " will lie with certainty in the interval ", Cell[BoxData[ \(TraditionalForm\`\((x - 10\^\(-a\)/2, x + 10\^\(-a\)/2)\)\)]], "\[InvisibleSpace]", Cell[BoxData[ \(TraditionalForm\` = \)]], "\[InvisibleSpace]", Cell[BoxData[ \(TraditionalForm\`\((x - x\ 10\^\(-p\)/2, x + x\ 10\^\(-p\)/2)\)\)]], " ", StyleBox["(a distinction between open and closed intervals is not useful \ for approximative numbers).", FontColor->RGBColor[1, 0, 0]] }], "Text", CellMargins->{{54, Inherited}, {Inherited, Inherited}}, Background->GrayLevel[0.900008]], Cell[TextData[{ "A distinction between open and closed intervals is important \ mathematically. For example, ", Cell[BoxData[ \(TraditionalForm\`\((0, 10\^\(-10\))\)\)]], " and ", Cell[BoxData[ \(TraditionalForm\`\([0, 10\^\(-10\)]\)\)]], " are completely different. We can not decide whether ", Cell[BoxData[ \(TraditionalForm\`0\)]], " is included in the interval or not if we do not know that the interval is \ closed. Anyway, we have to distinguish between open and closed if we would \ like to know the results with precision assurance. We discuss this topic in \ the later section." }], "Text"], Cell[TextData[{ "For complex numbers, the definition of accuracy is not straight forward \ (eg. maximum or minimum of real and imaginary parts). We have not found the \ official definition in the ", StyleBox["Mathematica", FontSlant->"Italic"], " book, however, we can see the definition in the ", StyleBox["Mathematica", FontSlant->"Italic"], " guide book as follows. " }], "Text"], Cell[TextData[{ "The accuracy of a complex number ", Cell[BoxData[ \(TraditionalForm\`z = x\ + \ i\ y\)]], ", ", Cell[BoxData[ \(TraditionalForm\`x\)]], " and ", Cell[BoxData[ \(TraditionalForm\`y\)]], " being real, is defined in the following way: ", Cell[BoxData[ \(TraditionalForm\`\(\(accuracy(z)\)\(=\)\)\)]], " ", Cell[BoxData[ \(TraditionalForm\`\(-1\)/2 log\_10\)]], " ", Cell[BoxData[ \(TraditionalForm\`\((10\^\(\(-2\) \(accuracy(x)\)\) + 10\^\(\(-2\) \(accuracy(y)\)\))\)\)]], ". The precision of a complex number ", Cell[BoxData[ \(TraditionalForm\`z = x\ + \ i\ y\)]], ", ", Cell[BoxData[ \(TraditionalForm\`x\)]], " and ", Cell[BoxData[ \(TraditionalForm\`y\)]], " being real, is defined in the following way: ", Cell[BoxData[ \(TraditionalForm\`precision(z) = accuracy(z)\)]], Cell[BoxData[ \(TraditionalForm\`\(+\(\(log\_10\)(\[LeftBracketingBar]z\ \[RightBracketingBar])\)\)\)]], ". This is the exact equivalent of the corresponding formula for real \ numbers. " }], "Text", CellMargins->{{54, Inherited}, {Inherited, Inherited}}, Background->GrayLevel[0.900008]], Cell[TextData[{ "We note that we can find the same definition except for complex numbers, \ with more mathematical notations in the paper by Sofroniou and Spaletta \ [SS05]. Those informations are redundant especially after the above quotes \ from the ", StyleBox["Mathematica", FontSlant->"Italic"], " book and the guide book. Please check the section 2 in that paper if you \ would like to see them." }], "Text"] }, Open ]], Cell[CellGroupData[{ Cell["Error Tracking System", "Subsubsection"], Cell[TextData[{ "Also, we can find the following paragraph that indicates the same fact as \ in the ", StyleBox["Mathematica", FontSlant->"Italic"], " book, in the ", StyleBox["Mathematica", FontSlant->"Italic"], " guide book for numerics." }], "Text"], Cell[TextData[{ StyleBox["Mathematica", FontSlant->"Italic"], "\[CloseCurlyQuote]s high\[Hyphen]precision arithmetic is based on \ significance arithmetic. This means that the result of a \ high\[Hyphen]precision calculation is a number (composed of digits) including \ the knowledge of which of the digits are correct. In ", StyleBox["OutputForm", "MR"], " and ", StyleBox["StandardForm", "MR"], " only the certified digits are printed. ", StyleBox["InputForm", "MR"], " and ", StyleBox["FullForm", "MR"], " will display all digits together with the information of how many of them \ are correct." }], "Text", CellMargins->{{54, Inherited}, {Inherited, Inherited}}, Background->GrayLevel[0.900008]], Cell[TextData[{ "By the above official documents, most of users, especially beginners tend \ to believe that all significant digits computed by ", StyleBox["Mathematica", FontSlant->"Italic"], " are mathematically correct. However, this is not true and some actual \ evidences are shown in the later section. In fact, we can find the following \ argument in the guide book, which indicates that arbitrary precision numbers \ are computed by only significance arithmetic without accuracy assurance. This \ is included in a context: how does ", StyleBox["Mathematica", FontSlant->"Italic"], " checks an identity numerically?" }], "Text"], Cell["\<\ The probability that the identity would be wrong and that \ accumulated errors in the carried out arithmetic make a wrong identity \ correct is vanishing small.\ \>", "Text", CellMargins->{{54, Inherited}, {Inherited, Inherited}}, Background->GrayLevel[0.900008]], Cell[TextData[{ "One might think that checking identities numerically and mathematical \ correctness of significant digits are not the same problem hence there are \ still possibilities that the above arguments in the ", StyleBox["Mathematica", FontSlant->"Italic"], " book and the guide book are mathematically correct. Unfortunately, the \ tracking system is not mathematically correct but it is only a reasonable \ cost-effective significance arithmetic since we can find the following \ argument in the guide book and the same words in the paper by Sofroniou and \ Spaletta." }], "Text"], Cell[TextData[{ "The formula for determining the precision of the output is based on the \ first\[Hyphen]order Taylor series of ", Cell[BoxData[ \(TraditionalForm\`f(x)\)]], ". This means that this precision model will be accurate for ", Cell[BoxData[ FormBox[ RowBox[{ FractionBox[ StyleBox[ RowBox[{"\[Delta]", StyleBox["x", "TI"]}]], "x"], "\[LessLess]", "1"}], TraditionalForm]]], ". For arguments of ", Cell[BoxData[ \(TraditionalForm\`f(x)\)]], " with a small precision, ", StyleBox["Mathematica", FontSlant->"Italic"], "\[CloseCurlyQuote]s high\[Hyphen]precision arithmetic might give either \ too pessimistic or even wrong results." }], "Text", CellMargins->{{54, Inherited}, {Inherited, Inherited}}, Background->GrayLevel[0.900008]], Cell[TextData[{ "In the paper by Sofroniou and Spaletta, they wrote an easier example for \ understanding. Let ", Cell[BoxData[ \(TraditionalForm\`x\)]], " and ", Cell[BoxData[ \(TraditionalForm\`y\)]], " be enough large positive arbitrary precision numbers with relative errors \ ", Cell[BoxData[ \(TraditionalForm\`\[Epsilon]\_x\)]], " and ", Cell[BoxData[ \(TraditionalForm\`\[Epsilon]\_y\)]], ", respectively, such that ", Cell[BoxData[ \(TraditionalForm\`\[Epsilon]\_x = 1\/2\[CenterDot]10\^\(-\(p(x)\)\)\)]], " and ", Cell[BoxData[ \(TraditionalForm\`\[Epsilon]\_y = 1\/2\[CenterDot]10\^\(-\(p(y)\)\)\)]], ". Hence, we have true values ", Cell[BoxData[ \(TraditionalForm\`x\&_\)]], " and ", Cell[BoxData[ \(TraditionalForm\`y\&_\)]], " of ", Cell[BoxData[ \(TraditionalForm\`x\)]], " and ", Cell[BoxData[ \(TraditionalForm\`y\)]], " satisfying ", Cell[BoxData[ \(TraditionalForm\`x\&_\ \[Element] \ \([x(1 - \[Epsilon]\_x), \ x(1 + \[Epsilon]\_x)]\)\)]], " and ", Cell[BoxData[ \(TraditionalForm\`y\&_\ \[Element] \ \([y(1 - \[Epsilon]\_y), \ y(1 + \[Epsilon]\_y)]\)\)]], ", respectively. We think the product of these two intervals. The result of \ the product is mathematically as follows." }], "Text"], Cell[BoxData[ \(x\&_\ y\&_\ \[Element] \ \([x\ y \((1 - \[Epsilon]\_x - \[Epsilon]\_y \ + \(\[Epsilon]\_x\) \[Epsilon]\_y)\), \ x\ y \((1 + \[Epsilon]\_x + \[Epsilon]\_y + \(\[Epsilon]\_x\) \ \[Epsilon]\_y)\)]\)\)], "DisplayFormula"], Cell[TextData[{ "However, significance arithmetic in ", StyleBox["Mathematica", FontSlant->"Italic"], " generates the following interval instead of the above. It neglects the \ vanishing small value ", Cell[BoxData[ \(TraditionalForm\`\(\[Epsilon]\_x\) \[Epsilon]\_y\)]], ". " }], "Text"], Cell[BoxData[ \(x\&_\ y\&_\ \[Element] \ \([x\ y \((1 - \[Epsilon]\_x - \[Epsilon]\_y)\ \), \ x\ y \((1 + \[Epsilon]\_x + \[Epsilon]\_y)\)]\)\)], "DisplayFormula"], Cell[TextData[{ "Although this error model is not wrong or perhaps we should say that it is \ the reasonable and conventional significance arithmetic, that the official ", StyleBox["Mathematica", FontSlant->"Italic"], " book does not have the above information is much dangerous. All the users \ must have the right to know the mechanism of arbitrary precision numbers in \ ", StyleBox["Mathematica", FontSlant->"Italic"], ". We have to know the mechanism before using it to know what we get as \ answers. The ", StyleBox["Mathematica", FontSlant->"Italic"], " book should not use \"correct\" digits since most of users think that \ \"correct\" means mathematically correct while it is not mathematically \ correct." }], "Text"], Cell[TextData[{ "Moreover, Fateman [Fateman92] reported many things about ", StyleBox["Mathematica", FontSlant->"Italic"], " (maybe version 1.2). In his paper, he introduced the following 4 versions \ for error tracking systems. It is a kind of evolutional process. We note that \ the following statement is a summary hence they are not the actual words." }], "Text"], Cell["\<\ Version 0: just high-precision or multi-precision numbers (there \ are not any accuracy informations). Version 1: ordinary significance arithmetic ( 3.0 means any numbers between \ 2.95 and 3.04 ). Version 2: accuracy and precision are merely bounds on the error introduced \ in each computation leading up to the present value, without any accuracy \ assurance. Version 3: accuracy and precision are merely bounds on the error introduced \ in each computation leading up to the present value, with accuracy \ assurance.\ \>", "Text", CellMargins->{{54, Inherited}, {Inherited, Inherited}}, Background->GrayLevel[0.900008]], Cell[TextData[{ "At the time when his paper was wrote, the tracking system of ", StyleBox["Mathematica", FontSlant->"Italic"], " may be something like version 1. According to the ", StyleBox["Mathematica", FontSlant->"Italic"], " book, we tend to think that the current tracking system is something like \ version 3, however, according to the ", StyleBox["Mathematica", FontSlant->"Italic"], " guide book and the paper by Sofroniou and Spaletta, we now can know that \ it is something only like version 2." }], "Text"] }, Open ]], Cell[CellGroupData[{ Cell["Converting to Arbitrary Precision Numbers", "Subsubsection"], Cell[TextData[{ "Even if we read the ", StyleBox["Mathematica", FontSlant->"Italic"], " guide book and the academic paper, we can not find any informations about \ this big problem. However, in the ", StyleBox["Mathematica", FontSlant->"Italic"], " guide book, we can find the following useful undocumented function ", StyleBox["$NumberBits", FontFamily->"Courier"], "." }], "Text"], Cell[TextData[{ "Floating\[Hyphen]point arithmetic with a variable number of digits. This \ is the method implemented in the current ", StyleBox["Mathematica", FontSlant->"Italic"], " kernel. Roughly speaking, the main idea is to simulate interval \ arithmetic by constantly maintaining a \[OpenCurlyDoubleQuote]few more digits\ \[CloseCurlyDoubleQuote] than needed (hereafter called guard digits), and to \ use them to analyze the error. " }], "Text", CellMargins->{{54, Inherited}, {Inherited, Inherited}}, Background->GrayLevel[0.900008]], Cell[TextData[{ "We can get knowledge of all (base 2) digits (the explicitly shown ones and \ the hidden ones) of a number in the form of their binary representation by \ using the undocumented function ", StyleBox["$NumberBits", "MR"], ". " }], "Text", CellMargins->{{54, Inherited}, {Inherited, Inherited}}, Background->GrayLevel[0.900008]], Cell[TextData[{ StyleBox["$NumberBits[", "MR"], StyleBox["number", "TI"], StyleBox["]", "MR"], " ", "gives a list of the form ", StyleBox["{", "MR"], StyleBox["sign", "TI"], StyleBox[", ", "MR"], StyleBox["listOfCorrectBits", "TI"], StyleBox[", ", "MR"], StyleBox["listOfGuardBits", "TI"], StyleBox[", ", "MR"], Cell[BoxData[ FormBox[ StyleBox["base2Exponent", "TI"], TraditionalForm]], "InlineFormula"], StyleBox["}", "MR"], " of the approximate real number ", StyleBox["approximateRealNumber", "TI"], "." }], "Text", CellFrame->True, CellMargins->{{54, Inherited}, {Inherited, Inherited}}, Background->GrayLevel[0.833326]], Cell["\<\ By this function, as in the later section, we can check the \ mechanism of the tracking system. Here, we show some examples.\ \>", "Text"], Cell[CellGroupData[{ Cell[BoxData[ \(NumericalMath`$NumberBits[0.1`10]\)], "Input", CellLabel->"In[2]:="], Cell[BoxData[ \({1, {1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1}, {1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0}, \(-3\)}\)], "Output", CellLabel->"Out[2]="] }, Open ]], Cell[CellGroupData[{ Cell[BoxData[ \(NumericalMath`$NumberBits[0.1`20]\)], "Input", CellLabel->"In[3]:="], Cell[BoxData[ \({1, {1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1}, {0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0}, \(-3\)}\)], "Output", CellLabel->"Out[3]="] }, Open ]], Cell[CellGroupData[{ Cell[BoxData[ \(NumericalMath`$NumberBits[0.1`30]\)], "Input", CellLabel->"In[4]:="], Cell[BoxData[ \({1, {1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0}, {1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0}, \(-3\)}\)], "Output", CellLabel->"Out[4]="] }, Open ]] }, Open ]], Cell[CellGroupData[{ Cell["Other Remarks", "Subsubsection"], Cell["\<\ In the guide book, we can find various undocumented informations \ about numerical calculations. \ \>", "Text"], Cell[TextData[{ "The behavior of ", StyleBox["Equal", "MR"], " and ", StyleBox["SameQ", "MR"], " with respect to floating point numbers can be influenced by the two \ functions ", StyleBox["Experimental`$EqualTolerance", "MR"], " and ", StyleBox["Experimental`$SameQTolerance", "MR"], ". They represent the number of digits such that two numbers are considered \ to be equal or the same. The current values are as follows." }], "Text", CellMargins->{{54, Inherited}, {Inherited, Inherited}}, Background->GrayLevel[0.900008]], Cell["This indicates the reason of the following examples.", "Text"], Cell[CellGroupData[{ Cell[BoxData[ \(1.00000000`10 == 1.00000001`10\)], "Input", CellLabel->"In[47]:="], Cell[BoxData[ \(True\)], "Output", CellLabel->"Out[47]="] }, Open ]], Cell[CellGroupData[{ Cell[BoxData[ \(1.00000000`10 === 1.00000001`10\)], "Input", CellLabel->"In[48]:="], Cell[BoxData[ \(False\)], "Output", CellLabel->"Out[48]="] }, Open ]], Cell[CellGroupData[{ Cell[BoxData[ \(1.00000000`10 === 1.0000000002`10\)], "Input", CellLabel->"In[51]:="], Cell[BoxData[ \(True\)], "Output", CellLabel->"Out[51]="] }, Open ]], Cell[TextData[{ "Because the two functions ", StyleBox["Experimental`$EqualTolerance", "MR"], " and ", StyleBox["Experimental`$SameQTolerance", "MR"], " are the following values, as in the guide book. Anyway, we have to set \ these values 0s for strict mathematical checking of equality and identity \ although ", StyleBox["Mathematica", FontSlant->"Italic"], " neglects all the incorrect digits (", StyleBox["Mathematica", FontSlant->"Italic"], " thinks they are incorrect) for checking of equality and identity." }], "Text"], Cell[CellGroupData[{ Cell[BoxData[ \({Experimental`$EqualTolerance, Experimental`$SameQTolerance}\)], "Input",\ CellLabel->"In[52]:="], Cell[BoxData[ \({2.1072099696478683`, 0.3010299956639812`}\)], "Output", CellLabel->"Out[52]="] }, Open ]], Cell[CellGroupData[{ Cell[BoxData[ \(\(?Experimental`$EqualTolerance\)\)], "Input", CellLabel->"In[53]:="], Cell[BoxData[ RowBox[{"\<\"$EqualTolerance gives the number of decimal digits by which \ two numbers can disagree and still be considered equal according to \ Equal.\"\>", " ", ButtonBox[ StyleBox["More\[Ellipsis]", "SR"], ButtonData:>"Experimental`$EqualTolerance", Active->True, ButtonStyle->"RefGuideLink"]}]], "Print", CellTags->"Info3351452680-1623943"] }, Open ]], Cell[CellGroupData[{ Cell[BoxData[ \(\(?Experimental`$SameQTolerance\)\)], "Input", CellLabel->"In[54]:="], Cell[BoxData[ RowBox[{"\<\"$SameQTolerance gives the number of decimal digits by which \ two numbers can disagree and still be considered the same according to SameQ.\ \"\>", " ", ButtonBox[ StyleBox["More\[Ellipsis]", "SR"], ButtonData:>"Experimental`$SameQTolerance", Active->True, ButtonStyle->"RefGuideLink"]}]], "Print", CellTags->"Info3351452686-9513144"] }, Open ]] }, Open ]] }, Open ]], Cell[CellGroupData[{ Cell["Remarks", "Subsection"], Cell[TextData[{ StyleBox["Mathematica", FontSlant->"Italic"], "'s precision and accuracy tracking system is not designed for numerical \ computations with precision assurance. Hence, results may have wrong \ precision and accuracy by misadventure, though they are almost always \ correct. Moreover, there is no mathematical information about converting to \ arbitrary precision numbers since the system is designed for having both of \ reasonable computation speed and reasonable correctness, not for mathematical \ correctness." }], "Text"], Cell[TextData[{ "We note that we have been trying to get more informations about ", StyleBox["Mathematica", FontSlant->"Italic"], "'s arbitrary precision numbers for getting more mathematically trustworthy \ results and certifying the results calculated by our package. After tons of \ emails from July to November 2005 with Wolfram Research Inc., we got only \ these informations: 1) there is the academic paper by Sofroniou and Spaletta \ [SS05] and 2) the ", StyleBox["Mathematica", FontSlant->"Italic"], " book is the only official document for numerical computations in ", StyleBox["Mathematica", FontSlant->"Italic"], " . We have needed any useful informations about the ", StyleBox["Mathematica", FontSlant->"Italic"], "'s error tracking system and its arbitrary precision numbers and we have \ not gotten them." }], "Text"] }, Open ]] }, Open ]], Cell[CellGroupData[{ Cell["Actual Behaviors and Problems", "Section"], Cell["\<\ In this section, we show some examples that indicate the official \ documents (including Sofroniou and Spaletta's paper) are not correct or not \ enough to describe all the system.\ \>", "Text"], Cell[CellGroupData[{ Cell["Precision and Accuracy", "Subsection"], Cell[TextData[{ "In this section, we figure out the insides of precision and accuracy by \ the function ", StyleBox["NumericalMath`$NumberBits", FontFamily->"Courier"], "." }], "Text"], Cell[TextData[{ "At first, we examine how many number of digits in binary form are used in \ the case of using ", ButtonBox["SetPrecision", ButtonStyle->"RefGuideLink"], ". In the below output, we can see ", Cell[BoxData[ \(TraditionalForm\`{{significant\ digits, \ hidden\ guard\ digits}, \ specified\ digits\ in\ binary\ form}\)]], " for each specified precision ", Cell[BoxData[ \(TraditionalForm\`p\)]], " where hidden guard digits may not be significant and only used for \ keeping accurate computations." }], "Text"], Cell[CellGroupData[{ Cell[BoxData[ \(Table[{Length /@ \(NumericalMath`$NumberBits[ SetPrecision[2, p]]\)[\([{2, 3}]\)], N[Log[2, 10^p - 1]]}, {p, 1, 20}]\)], "Input", CellLabel->"In[1]:="], Cell[BoxData[ \({{{3, 63}, 3.1699250014423126`}, {{7, 59}, 6.6293566200796095`}, {{10, 56}, 9.96434086779242`}, {{13, 53}, 13.287568102831404`}, {{17, 49}, 16.609626047414267`}, {{20, 46}, 19.931567126628412`}, {{23, 43}, 23.253496519942026`}, {{27, 39}, 26.57542474467195`}, {{30, 36}, 29.897352852543566`}, {{33, 65}, 33.21928094872935`}, {{37, 61}, 36.54120904374656`}, {{40, 58}, 39.863137138646906`}, {{43, 55}, 43.18506523353557`}, {{47, 51}, 46.50699332842305`}, {{50, 48}, 49.82892142331043`}, {{53, 45}, 53.1508495181978`}, {{56, 42}, 56.472777613085164`}, {{60, 38}, 59.79470570797252`}, {{63, 35}, 63.11663380285989`}, {{66, 64}, 66.43856189774725`}}\)], "Output", CellLabel->"Out[1]="] }, Open ]], Cell["\<\ It seems that a number of significant digits is generated by \ rounding the input precision into the nearest integer. The following four \ examples follow this hypothesis. The last two examples indicate the rounding \ mode at the center.\ \>", "Text"], Cell[CellGroupData[{ Cell[BoxData[ \({Length /@ \(NumericalMath`$NumberBits[ SetPrecision[2, 20.63]]\)[\([{2, 3}]\)], N[Log[2, 10^20.63 - 1]]}\)], "Input", CellLabel->"In[2]:="], Cell[BoxData[ \({{69, 61}, 68.53137659752628`}\)], "Output", CellLabel->"Out[2]="] }, Open ]], Cell[CellGroupData[{ Cell[BoxData[ \({Length /@ \(NumericalMath`$NumberBits[ SetPrecision[2, 20.62]]\)[\([{2, 3}]\)], N[Log[2, 10^20.62 - 1]]}\)], "Input", CellLabel->"In[3]:="], Cell[BoxData[ \({{68, 62}, 68.49815731657742`}\)], "Output", CellLabel->"Out[3]="] }, Open ]], Cell[CellGroupData[{ Cell[BoxData[ RowBox[{"{", RowBox[{ RowBox[{"Length", "/@", RowBox[{ RowBox[{"NumericalMath`$NumberBits", "[", RowBox[{"SetPrecision", "[", RowBox[{"2", ",", StyleBox["20.620554702982714", ShowSpecialCharacters->False, ShowStringCharacters->True, NumberMarks->True]}], "]"}], "]"}], "[", \([{2, 3}]\), "]"}]}], ",", RowBox[{"FullForm", "[", RowBox[{"Log", "[", RowBox[{"2", ",", RowBox[{ RowBox[{"10", "^", StyleBox["20.620554702982714", ShowSpecialCharacters->False, ShowStringCharacters->True, NumberMarks->True]}], "-", "1"}]}], "]"}], "]"}]}], "}"}]], "Input", CellLabel->"In[4]:="], Cell[BoxData[ RowBox[{"{", RowBox[{\({68, 62}\), ",", TagBox[ StyleBox["68.5`", ShowSpecialCharacters->False, ShowStringCharacters->True, NumberMarks->True], FullForm]}], "}"}]], "Output", CellLabel->"Out[4]="] }, Open ]], Cell[CellGroupData[{ Cell[BoxData[ RowBox[{"{", RowBox[{ RowBox[{"Length", "/@", RowBox[{ RowBox[{"NumericalMath`$NumberBits", "[", RowBox[{"SetPrecision", "[", RowBox[{"2", ",", StyleBox["20.319524707318730", ShowSpecialCharacters->False, ShowStringCharacters->True, NumberMarks->True]}], "]"}], "]"}], "[", \([{2, 3}]\), "]"}]}], ",", RowBox[{"FullForm", "[", RowBox[{"Log", "[", RowBox[{"2", ",", RowBox[{ RowBox[{"10", "^", StyleBox["20.319524707318730", ShowSpecialCharacters->False, ShowStringCharacters->True, NumberMarks->True]}], "-", "1"}]}], "]"}], "]"}]}], "}"}]], "Input", CellLabel->"In[5]:="], Cell[BoxData[ RowBox[{"{", RowBox[{\({67, 63}\), ",", TagBox[ StyleBox["67.5`", ShowSpecialCharacters->False, ShowStringCharacters->True, NumberMarks->True], FullForm]}], "}"}]], "Output", CellLabel->"Out[5]="] }, Open ]], Cell[TextData[{ "Also, it seems that a number of hidden guard digits is generated as its \ summation of numbers of significant and hidden digits to be ", StyleBox["something", FontSlant->"Italic"], " + \"a multiple of 32\" as follows." }], "Text"], Cell[CellGroupData[{ Cell[BoxData[ \(Table[ Plus @@ \((Length /@ \(NumericalMath`$NumberBits[ SetPrecision[2, p]]\)[\([{2, 3}]\)])\), {p, 1, 50}]\)], "Input", CellLabel->"In[6]:="], Cell[BoxData[ \({66, 66, 66, 66, 66, 66, 66, 66, 66, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 130, 130, 130, 130, 130, 130, 130, 130, 130, 130, 162, 162, 162, 162, 162, 162, 162, 162, 162, 194, 194, 194, 194, 194, 194, 194, 194, 194, 194, 226, 226}\)], "Output", CellLabel->"Out[6]="] }, Open ]], Cell[TextData[{ StyleBox["$NumberBits[", "MR"], StyleBox["number", "TI"], StyleBox["]", "MR"], " gives a list of the form ", StyleBox["{", "MR"], StyleBox["sign", "TI"], StyleBox[", ", "MR"], StyleBox["listOfCorrectBits", "TI"], StyleBox[", ", "MR"], StyleBox["listOfGuardBits", "TI"], StyleBox[", ", "MR"], Cell[BoxData[ FormBox[ StyleBox["base2Exponent", "TI"], TraditionalForm]], "InlineFormula"], StyleBox["},", "MR"], "so we think that a number of digits used for ", StyleBox["sign", "TI"], " and ", StyleBox["base2Exponent", FontSlant->"Italic"], " is just ", StyleBox["something", FontSlant->"Italic"], " bits. However this is not true since ", StyleBox["base2Exponent", FontSlant->"Italic"], " uses 32 bits as follows. Therefore, still there are hidden informations \ in arbitrary precision numbers or just preserved for future uses." }], "Text"], Cell[CellGroupData[{ Cell[BoxData[ \(NumericalMath`$NumberBits[$MaxNumber]\)], "Input", CellLabel->"In[7]:="], Cell[BoxData[ \({1, {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 2147483296}\)], "Output", CellLabel->"Out[7]="] }, Open ]], Cell[CellGroupData[{ Cell[BoxData[ \(Log[2, 2147483296. ]\)], "Input", CellLabel->"In[8]:="], Cell[BoxData[ \(30.99999976352384`\)], "Output", CellLabel->"Out[8]="] }, Open ]], Cell[CellGroupData[{ Cell[BoxData[ \(Round@Log[2, 3 + 1. ]\)], "Input", CellLabel->"In[9]:="], Cell[BoxData[ \(2\)], "Output", CellLabel->"Out[9]="] }, Open ]], Cell["\<\ Though we do not know the purpose of something bits, we can expect \ the following formula.\ \>", "Text"], Cell[BoxData[ \(significant\ digits\ + \ hidden\ guard\ digits\ = \ \([log\ n + 1\/2 + \((positive\ tiny\ number)\)]\)\ + \ \((multiplier\ of\ \ 32)\)\)], "DisplayFormula"], Cell[TextData[{ "where ", Cell[BoxData[ \(TraditionalForm\`n\)]], " denotes the given number and ", Cell[BoxData[ \(TraditionalForm\`\([a]\)\)]], " means the integer nearest to ", Cell[BoxData[ \(TraditionalForm\`a\)]], "." }], "Text"] }, Open ]], Cell[CellGroupData[{ Cell["Error Tracking System", "Subsection"], Cell[TextData[{ "According to Sofroniou and Spaletta's paper, for enough large positive \ arbitrary precision numbers ", Cell[BoxData[ \(TraditionalForm\`x\)]], " and ", Cell[BoxData[ \(TraditionalForm\`y\)]], " such that true values ", Cell[BoxData[ \(TraditionalForm\`x\&_\)]], " and ", Cell[BoxData[ \(TraditionalForm\`y\&_\)]], " of ", Cell[BoxData[ \(TraditionalForm\`x\)]], " and ", Cell[BoxData[ \(TraditionalForm\`y\)]], " satisfying ", Cell[BoxData[ \(TraditionalForm\`x\&_\ \[Element] \ \([x(1 - \[Epsilon]\_x), \ x(1 + \[Epsilon]\_x)]\)\)]], " and ", Cell[BoxData[ \(TraditionalForm\`y\&_\ \[Element] \ \([y(1 - \[Epsilon]\_y), \ y(1 + \[Epsilon]\_y)]\)\)]], ", respectively. When we compute the product of ", Cell[BoxData[ \(TraditionalForm\`x\)]], " and ", Cell[BoxData[ \(TraditionalForm\`y\)]], ", ", StyleBox["Mathematica", FontSlant->"Italic"], " generates an arbitrary precision number corresponding to the following \ interval." }], "Text"], Cell[BoxData[ \(x\&_\ y\&_\ \[Element] \ \([x\ y \((1 - \[Epsilon]\_x - \[Epsilon]\_y)\ \), \ x\ y \((1 + \[Epsilon]\_x + \[Epsilon]\_y)\)]\)\)], "DisplayFormula"], Cell[TextData[{ "We would like to check whether this argument is correct or not. Let ", Cell[BoxData[ \(TraditionalForm\`x\)]], " and ", Cell[BoxData[ \(TraditionalForm\`y\)]], " be the following two integers." }], "Text"], Cell[BoxData[{ \(\(x = 2;\)\), "\[IndentingNewLine]", \(\(y = 4;\)\)}], "InputOnly", CellLabel->"In[10]:="], Cell[TextData[{ "We suppose that accuracy of these two integers is 20 digits in the decimal \ system. Hence, accordingly, their absolute uncertainties ", Cell[BoxData[ \(TraditionalForm\`\[Delta]\_x\)]], " and ", Cell[BoxData[ \(TraditionalForm\`\[Delta]\_y\)]], " and their relative uncertainties ", Cell[BoxData[ \(TraditionalForm\`\[Epsilon]\_x\)]], " and ", Cell[BoxData[ \(TraditionalForm\`\[Epsilon]\_y\)]], " are defined as follows. We note that precision and accuracy in ", StyleBox["Mathematica", FontSlant->"Italic"], " denote a range of its uncertainty, however, in this context, ", Cell[BoxData[ \(TraditionalForm\`\[Delta]\_x\)]], ", ", Cell[BoxData[ \(TraditionalForm\`\[Delta]\_y\)]], ", ", Cell[BoxData[ \(TraditionalForm\`\[Epsilon]\_x\)]], " and ", Cell[BoxData[ \(TraditionalForm\`\[Epsilon]\_y\)]], " are satisfying ", Cell[BoxData[ \(TraditionalForm\`x\&_\ \[Element] \ \([x(1 - \[Epsilon]\_x), \ x(1 + \[Epsilon]\_x)]\)\)]], ", ", Cell[BoxData[ \(TraditionalForm\`y\&_\ \[Element] \ \([y(1 - \[Epsilon]\_y), \ y(1 + \[Epsilon]\_y)]\)\)]], ", ", Cell[BoxData[ \(TraditionalForm\`x\&_\ \[Element] \ \([x - \[Delta]\_x, \ x + \[Delta]\_x)\)\)]], " and ", Cell[BoxData[ \(TraditionalForm\`y\&_\ \[Element] \ \([y - \[Delta]\_y, \ y + \[Delta]\_y]\)\)]], "." }], "Text"], Cell[BoxData[{ \(\(acc = 20;\)\), "\[IndentingNewLine]", \(\(\[Delta]\_x = \((10^\(-acc\))\)/2;\)\), "\[IndentingNewLine]", \(\(\[Delta]\_y = \((10^\(-acc\))\)/2;\)\), "\[IndentingNewLine]", \(\(\[Epsilon]\_x = \[Delta]\_x/x;\)\), "\[IndentingNewLine]", \(\(\[Epsilon]\_y = \[Delta]\_y/y;\)\)}], "InputOnly", CellLabel->"In[12]:="], Cell[TextData[{ "We calculate accuracy of the product of ", Cell[BoxData[ \(TraditionalForm\`x\)]], " and ", Cell[BoxData[ \(TraditionalForm\`y\)]], " by different three ways. ", Cell[BoxData[ \(TraditionalForm\`xyA\)]], " represents the value calculated by the above definition. ", Cell[BoxData[ \(TraditionalForm\`xyB\)]], " represents the value calculated by the mathematical way. ", Cell[BoxData[ \(TraditionalForm\`xyC\)]], " represents the value by ", StyleBox["Mathematica", FontSlant->"Italic"], "'s tracking system." }], "Text"], Cell[BoxData[{ \(\(xyA = \(-Log[10, \ 2*x*y*\((\[Epsilon]\_x + \[Epsilon]\_y)\)]\);\)\), "\ \[IndentingNewLine]", \(\(xyB = \(-Log[10, \ 2*x*y*\((\[Epsilon]\_x + \[Epsilon]\_y - \[Epsilon]\_x*\[Epsilon]\ \_y)\)]\);\)\), "\[IndentingNewLine]", \(\(xyC = Accuracy[ SetAccuracy[x, acc]*\ SetAccuracy[y, acc]];\)\)}], "InputOnly", CellLabel->"In[17]:="], Cell["The result is as follows.", "Text"], Cell[BoxData[ \(showmp[n_] := NumberForm[N[n, 2*MachinePrecision], Ceiling[2*MachinePrecision]]\)], "InputOnly", CellLabel->"In[20]:="], Cell[CellGroupData[{ Cell[BoxData[ \(TableForm[{{"\", showmp[acc]}, {"\", showmp[xyA]}, {"\", showmp[xyB]}, {"\", showmp[xyC]}}]\)], "Input", CellLabel->"In[21]:="], Cell[BoxData[ TagBox[GridBox[{ {"\<\"acc\"\>", TagBox[ InterpretationBox["\<\"20.000000000000000000000000000000\"\>", 20.`31.909179540382006, AutoDelete->True], (NumberForm[ #, 32]&)]}, {"\<\"xyA\"\>", TagBox[ InterpretationBox["\<\"19.221848749616356367491233202020\"\>", 19.221848749616356367491233202020391662999001631354`31.\ 909179540382006, AutoDelete->True], (NumberForm[ #, 32]&)]}, {"\<\"xyB\"\>", TagBox[ InterpretationBox["\<\"19.221848749616356367491595114089\"\>", 19.221848749616356367491595114088644373889207193714`31.\ 909179540382006, AutoDelete->True], (NumberForm[ #, 32]&)]}, {"\<\"xyC\"\>", TagBox[ InterpretationBox["\<\"19.22184874961636\"\>", 19.221848749616356, AutoDelete->True], (NumberForm[ #, 32]&)]} }, RowSpacings->1, ColumnSpacings->3, RowAlignments->Baseline, ColumnAlignments->{Left}], Function[ BoxForm`e$, TableForm[ BoxForm`e$]]]], "Output"] }, Open ]], Cell[TextData[{ "This result is almost same as the definition. However, the last digit of \ ", Cell[BoxData[ \(TraditionalForm\`xyC\)]], " is different from those of ", Cell[BoxData[ \(TraditionalForm\`xyA\)]], " and ", Cell[BoxData[ \(TraditionalForm\`xyB\)]], " and this would cause critical problems according to circumstances since \ the actual value ", Cell[BoxData[ \(TraditionalForm\`xyC\)]], " is larger than the theoretical value ", Cell[BoxData[ \(TraditionalForm\`xyA\)]], " and this means that we can not trust the tracking system if we want to \ get mathematically correct results even for basic four operations." }], "Text"], Cell[TextData[{ "The following other example does not cause any critical problems since the \ actual value ", Cell[BoxData[ \(TraditionalForm\`xyC\)]], " is smaller than the theoretical value ", Cell[BoxData[ \(TraditionalForm\`xyA\)]], "." }], "Text"], Cell[CellGroupData[{ Cell[BoxData[{ \(\(acc = 2708664523\/130361190;\)\), "\n", \(\(\[Delta]\_x = \((10^\(-acc\))\)/2;\)\), "\n", \(\(\[Delta]\_y = \((10^\(-acc\))\)/2;\)\), "\n", \(\(\[Epsilon]\_x = \[Delta]\_x/x;\)\), "\n", \(\(\[Epsilon]\_y = \[Delta]\_y/y;\)\), "\n", \(\(xyA = \(-Log[10, \ 2*x*y*\((\[Epsilon]\_x + \[Epsilon]\_y)\)]\);\)\), "\n", \(\(xyB = \(-Log[10, \ 2*x*y*\((\[Epsilon]\_x + \[Epsilon]\_y - \[Epsilon]\_x*\[Epsilon]\ \_y)\)]\);\)\), "\n", \(\(xyC = Accuracy[SetAccuracy[x, acc]*\ SetAccuracy[y, acc]];\)\), "\n", \(TableForm[{{"\", showmp[acc]}, {"\", showmp[xyA]}, {"\", showmp[xyB]}, {"\", showmp[xyC]}}]\)}], "Input", CellLabel->"In[22]:="], Cell[BoxData[ TagBox[GridBox[{ {"\<\"acc\"\>", TagBox[ InterpretationBox["\<\"20.778151250383645623363824770240\"\>", 20.778151250383645623363824770240283937266912031103`31.\ 909179540382006, AutoDelete->True], (NumberForm[ #, 32]&)]}, {"\<\"xyA\"\>", TagBox[ InterpretationBox["\<\"20.000000000000001990855057972261\"\>", 20.000000000000001990855057972260675623580854672117`31.\ 909179540382006, AutoDelete->True], (NumberForm[ #, 32]&)]}, {"\<\"xyB\"\>", TagBox[ InterpretationBox["\<\"20.000000000000001990855118290939\"\>", 20.000000000000001990855118290938717741613110107544`31.\ 909179540382006, AutoDelete->True], (NumberForm[ #, 32]&)]}, {"\<\"xyC\"\>", TagBox[ InterpretationBox["\<\"20.\"\>", 19.999999999999996, AutoDelete->True], (NumberForm[ #, 32]&)]} }, RowSpacings->1, ColumnSpacings->3, RowAlignments->Baseline, ColumnAlignments->{Left}], Function[ BoxForm`e$, TableForm[ BoxForm`e$]]]], "Output"] }, Open ]] }, Open ]], Cell[CellGroupData[{ Cell["Converting to Arbitrary Precision Numbers", "Subsection"], Cell["\<\ We can not find any information how to convert numbers to arbitrary \ precision numbers. Moreover, at least, converting to arbitrary precision \ numbers has the following problem.\ \>", "Text"], Cell[CellGroupData[{ Cell[BoxData[ \(FullForm[2`7]\)], "Input", CellLabel->"In[37]:="], Cell[BoxData[ TagBox[ StyleBox["2.`7.000000000000001", ShowSpecialCharacters->False, ShowStringCharacters->True, NumberMarks->True], FullForm]], "Output"] }, Open ]], Cell[CellGroupData[{ Cell[BoxData[ \(Table[{NumberForm[Precision[SetPrecision[2, p]], 32], p}, {p, 1, 64}]\)], "Input", CellLabel->"In[38]:="], Cell[BoxData[ RowBox[{"{", RowBox[{ RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"1.\"\>", 0.99999999999999989, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "1"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"2.\"\>", 1.9999999999999998, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "2"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"3.\"\>", 2.9999999999999996, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "3"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"4.\"\>", 3.9999999999999996, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "4"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"5.000000000000002\"\>", 5.0000000000000018, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "5"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"5.999999999999999\"\>", 5.9999999999999991, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "6"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"7.000000000000001\"\>", 7.0000000000000009, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "7"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"7.999999999999999\"\>", 7.9999999999999991, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "8"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"9.\"\>", 9.0000000000000018, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "9"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"10.\"\>", 10.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "10"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"11.\"\>", 11.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "11"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"12.\"\>", 12.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "12"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"13.\"\>", 13.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "13"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"14.\"\>", 14.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "14"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"15.\"\>", 15.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "15"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"16.\"\>", 16.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "16"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"17.\"\>", 17.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "17"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"18.\"\>", 18.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "18"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"19.\"\>", 19.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "19"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"20.\"\>", 20.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "20"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"21.\"\>", 21.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "21"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"22.\"\>", 22.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "22"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"23.\"\>", 23.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "23"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"24.\"\>", 24.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "24"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"25.\"\>", 25.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "25"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"26.\"\>", 26.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "26"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"27.\"\>", 27.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "27"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"28.\"\>", 28.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "28"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"29.\"\>", 29.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "29"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"30.\"\>", 30.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "30"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"31.\"\>", 30.999999999999996, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "31"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"32.\"\>", 32.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "32"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"33.\"\>", 33.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "33"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"34.\"\>", 34.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "34"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"35.\"\>", 35.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "35"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"36.\"\>", 36.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "36"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"37.\"\>", 37.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "37"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"38.\"\>", 38.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "38"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"39.\"\>", 39.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "39"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"40.\"\>", 40.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "40"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"41.\"\>", 41.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "41"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"42.\"\>", 42.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "42"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"43.\"\>", 43.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "43"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"44.\"\>", 44.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "44"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"44.99999999999999\"\>", 44.999999999999993, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "45"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"46.\"\>", 46.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "46"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"47.\"\>", 47.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "47"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"48.\"\>", 48.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "48"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"49.\"\>", 49.000000000000007, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "49"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"50.\"\>", 50.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "50"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"51.\"\>", 51.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "51"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"52.\"\>", 52.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "52"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"53.00000000000001\"\>", 53.000000000000007, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "53"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"54.\"\>", 54.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "54"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"55.\"\>", 55.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "55"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"56.\"\>", 56.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "56"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"57.\"\>", 57.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "57"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"58.\"\>", 58.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "58"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"59.\"\>", 59.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "59"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"60.\"\>", 60.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "60"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"61.\"\>", 61.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "61"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"61.99999999999999\"\>", 61.999999999999993, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "62"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"63.\"\>", 63.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "63"}], "}"}], ",", RowBox[{"{", RowBox[{ TagBox[ InterpretationBox["\<\"64.\"\>", 64.0, AutoDelete->True], (NumberForm[ #, 32]&)], ",", "64"}], "}"}]}], "}"}]], "Output", CellLabel->"Out[38]="] }, Open ]], Cell[TextData[{ "In these cases, we specifies only 5, 7 or 53 significant digits, however, \ the result number has a little bit larger significant digits. This may \ violate the given range of uncertainty. Since according to the guide book, ", StyleBox["NumericalMath`$NumberBits", FontFamily->"Courier"], " gives all of the binary information of the number, we may think that \ precision is related to the number of significant digits. However, this is \ not true. There must exist other binary informations on arbitrary precision \ numbers preserving precision and accuracy or some conversion mechanisms." }], "Text"], Cell[CellGroupData[{ Cell[BoxData[ \(Table[{Log[ 10. , \(-1\) + 2^Length[\(NumericalMath`$NumberBits[ SetPrecision[2, p]]\)[\([2]\)]]], p}, {p, 1, 64}]\)], "Input", CellLabel->"In[3]:="], Cell[BoxData[ \({{0.8450980400142567`, 1}, {2.103803720955957`, 2}, {3.0098756337121597`, 3}, {3.9133369259326227`, 4}, {5.117506612871095`, 5}, {6.020599499103933`, 6}, {6.923689848499627`, 7}, {8.127809879691746`, 8}, {9.030899869514966`, 9}, {9.93398985686082`, 10}, {11.138109839564143`, 11}, {12.04119982655885`, 12}, {12.944289813551139`, 13}, {14.148409796207112`, 14}, {15.051499783199057`, 15}, {15.954589770191001`, 16}, {16.857679757182943`, 17}, {18.061799739838868`, 18}, {18.964889726830812`, 19}, {19.867979713822756`, 20}, {21.07209969647868`, 21}, {21.975189683470624`, 22}, {22.878279670462568`, 23}, {24.082399653118493`, 24}, {24.985489640110433`, 25}, {25.888579627102377`, 26}, {27.092699609758302`, 27}, {27.99578959675025`, 28}, {28.898879583742186`, 29}, {30.102999566398115`, 30}, {31.006089553390055`, 31}, {31.909179540382002`, 32}, {33.11329952303793`, 33}, {34.01638951002987`, 34}, {34.91947949702181`, 35}, {36.123599479677736`, 36}, {37.02668946666968`, 37}, {37.929779453661624`, 38}, {39.13389943631755`, 39}, {40.03698942330949`, 40}, {40.940079410301436`, 41}, {42.14419939295736`, 42}, {43.047289379949305`, 43}, {43.95037936694125`, 44}, {44.853469353933185`, 45}, {46.05758933658912`, 46}, {46.96067932358106`, 47}, {47.863769310573005`, 48}, {49.06788929322893`, 49}, {49.97097928022087`, 50}, {50.87406926721282`, 51}, {52.078189249868736`, 52}, {52.98127923686068`, 53}, {53.88436922385263`, 54}, {55.08848920650855`, 55}, {55.9915791935005`, 56}, {56.89466918049244`, 57}, {58.09878916314836`, 58}, {59.001879150140304`, 59}, {59.90496913713225`, 60}, {61.10908911978818`, 61}, {62.01217910678011`, 62}, {62.915269093772054`, 63}, {64.11938907642798`, 64}}\)], "Output",\ CellLabel->"Out[3]="] }, Open ]] }, Open ]], Cell[CellGroupData[{ Cell["Remarks", "Subsection"], Cell["\<\ As in the above sections, there are two big problem: 1) where do \ precision and accuracy come from? 2) how are precision and accuracy modified? \ even though we have some kind of official documents. These differences \ between official and actual behaviors might be occurred by the same \ undocumented reason, rounding modes for example. Anyway, at this time, \ mathematically or non-mathematically we should not trust error bounds along \ with arbitrary precision numbers.\ \>", "Text"] }, Open ]] }, Open ]], Cell[CellGroupData[{ Cell["Our Resolution", "Section"], Cell["\<\ Our package guarantees all the results mathematically except some \ functions. Hence we have to use significance arithmetic with precision \ assurance. Basically, in our package, all the coefficients of representing \ polynomials of polynomial sets with error bounds are exact rational numbers \ while those error bounds are represented by floating point numbers. \ Therefore, we need an error tracking system for only the following \ functionalities.\ \>", "Text"], Cell["\<\ 1) Computing with error bounds that are represented by floating \ point numbers.\ \>", "Text"], Cell[TextData[{ "2) Conversing the given ", StyleBox["Mathematica", FontSlant->"Italic"], " expression into the corresponding exact rational expression with an error \ bound." }], "Text"], Cell[TextData[{ "3) Conversing the given our package's expression into the corresponding \ normal ", StyleBox["Mathematica", FontSlant->"Italic"], " expression." }], "Text"], Cell["4) Computing singular values and matrix inverses.", "Text"], Cell["\<\ We note that the following resolutions were not used in earlier \ versions of our package. After and including version 0.5 use the resolutions.\ \ \>", "Text"], Cell[CellGroupData[{ Cell["Using Rational Interval Arithmetic and Conversion", "Subsection"], Cell[TextData[{ "Since the ", StyleBox["Mathematica", FontSlant->"Italic"], "'s error tracking system is not trustworthy, we use rational interval \ arithmetic in our package internally. However, the ", StyleBox["Mathematica", FontSlant->"Italic"], "'s own interval arithmetic is given only for real numbers not for complex \ numbers, hence we have to extend ", StyleBox["Mathematica", FontSlant->"Italic"], "'s interval arithmetic to complex intervals. This workaround using \ rational intervals guarantees the internal results in our package though it \ is time-consuming and mostly over-estimated." }], "Text"], Cell[TextData[{ "Although internal arithmetic is done by rational interval arithmetic, the \ rest of problems is converting ", StyleBox["Mathematica", FontSlant->"Italic"], "'s arbitrary precision numbers into rational intervals and vice versa. \ However, we can not find any complete information on arbitrary precision \ numbers. ", StyleBox["NumericalMath`$NumberBits", FontFamily->"Courier"], " and the following useful functions are only introduced in the ", StyleBox["Mathematica", FontSlant->"Italic"], " guide book." }], "Text"], Cell[BoxData[ \(Float2Rational[nd_List] := First[nd]*2^Last[nd]* nd[\([2]\)] . Table[2^\(-i\), {i, Length[nd[\([2]\)]]}]\)], "InputOnly", CellLabel->"In[31]:="], Cell[BoxData[ \(FullFloat2Rational[nd_List] := First[nd]*2^Last[nd]* Join[nd[\([2]\)], nd[\([3]\)]] . Table[2^\(-i\), {i, Length[nd[\([2]\)]] + Length[nd[\([3]\)]]}]\)], "InputOnly", CellLabel->"In[32]:="], Cell[BoxData[ \(Float2Rational[n_?NumberQ] := Float2Rational[NumericalMath`$NumberBits[n]]\)], "InputOnly", CellLabel->"In[31]:="], Cell[BoxData[ \(FullFloat2Rational[n_?NumberQ] := FullFloat2Rational[NumericalMath`$NumberBits[n]]\)], "InputOnly", CellLabel->"In[32]:="], Cell[TextData[{ "The above two functions give rational numbers corresponding to internal \ binary expressions of arbitrary precision numbers. Since our package is for \ ", StyleBox["Mathematica", FontSlant->"Italic"], ", we have to obey the manner of ", StyleBox["Mathematica", FontSlant->"Italic"], " hence we trust all the input values from outside of the package. We leave \ it up to users' judgements that the arbitrary precision numbers are \ trustworthy or not." }], "Text"], Cell["\<\ We convert arbitrary floating numbers into rational intervals very \ carefully even if they are too over-estimated, while converting rational \ intervals into floating-point numbers is straight forward, as follows.\ \>", \ "Text"], Cell[BoxData[ \(SNAPFloat2Rational[n_] := Interval[Rationalize[n, 0] + {\(-1\), 1}* Max[\((10^\(-Interval[ Rationalize[Accuracy[n], 0]*\((1 + {\(-1\), 1}*10^\(-MachinePrecision\))\)]\))\)/ 2]]\)], "InputOnly", CellLabel->"In[169]:="], Cell[BoxData[ \(SNAPRational2Float[n_Interval] := SetAccuracy[\((Min[n] + Max[n])\)/ 2, \(-Log[10, Abs[Max[n] - Min[n]]]\)]\)], "InputOnly", CellLabel->"In[170]:="], Cell["\<\ At least, these functions run against to the following example \ which was introduced in the former section.\ \>", "Text"], Cell[BoxData[{ \(\(x = 2;\)\), "\[IndentingNewLine]", \(\(y = 4;\)\), "\[IndentingNewLine]", \(\(acc = 20;\)\), "\[IndentingNewLine]", \(\(\[Delta]\_x = \((10^\(-acc\))\)/2;\)\), "\[IndentingNewLine]", \(\(\[Delta]\_y = \((10^\(-acc\))\)/2;\)\), "\[IndentingNewLine]", \(\(\[Epsilon]\_x = \[Delta]\_x/x;\)\), "\[IndentingNewLine]", \(\(\[Epsilon]\_y = \[Delta]\_y/y;\)\), "\[IndentingNewLine]", \(\(xyA = \(-Log[10, \ 2*x*y*\((\[Epsilon]\_x + \[Epsilon]\_y)\)]\);\)\), "\ \[IndentingNewLine]", \(\(xyB = \(-Log[10, \ 2*x*y*\((\[Epsilon]\_x + \[Epsilon]\_y - \[Epsilon]\_x*\[Epsilon]\ \_y)\)]\);\)\), "\[IndentingNewLine]", \(\(xyC = Accuracy[ SetAccuracy[x, acc]*\ SetAccuracy[y, acc]];\)\), "\[IndentingNewLine]", \(\(xyD = \(Function[\(-Log[10, Abs[Max[#] - Min[#]]]\)]\)[ SNAPFloat2Rational[ SetAccuracy[x, acc]*\ SetAccuracy[y, acc]]];\)\)}], "InputOnly", CellLabel->"In[186]:="], Cell[CellGroupData[{ Cell[BoxData[ \(TableForm[{{"\", showmp[acc]}, {"\", showmp[xyA]}, {"\", showmp[xyB]}, {"\", showmp[xyC]}, {"\", showmp[xyD]}}]\)], "Input", CellLabel->"In[198]:="], Cell[BoxData[ TagBox[GridBox[{ {"\<\"acc\"\>", TagBox[ InterpretationBox["\<\"20.000000000000000000000000000000\"\>", 20.`31.909179540382006, AutoDelete->True], (NumberForm[ #, 32]&)]}, {"\<\"xyA\"\>", TagBox[ InterpretationBox["\<\"19.221848749616356367491233202020\"\>", 19.221848749616356367491233202020391662999001631354`31.\ 909179540382006, AutoDelete->True], (NumberForm[ #, 32]&)]}, {"\<\"xyB\"\>", TagBox[ InterpretationBox["\<\"19.221848749616356367491595114089\"\>", 19.221848749616356367491595114088644373889207193714`31.\ 909179540382006, AutoDelete->True], (NumberForm[ #, 32]&)]}, {"\<\"xyC\"\>", TagBox[ InterpretationBox["\<\"19.22184874961636\"\>", 19.221848749616356, AutoDelete->True], (NumberForm[ #, 32]&)]}, {"\<\"xyD\"\>", TagBox[ InterpretationBox["\<\"19.221848749616355222755119837326\"\>", 19.221848749616355222755119837325569862385621707698`31.\ 90917954038201, AutoDelete->True], (NumberForm[ #, 32]&)]} }, RowSpacings->1, ColumnSpacings->3, RowAlignments->Baseline, ColumnAlignments->{Left}], Function[ BoxForm`e$, TableForm[ BoxForm`e$]]]], "Output"] }, Open ]], Cell[TextData[{ "In our package, error bounds of polynomial sets are represented by ", StyleBox["Mathematica", FontSlant->"Italic"], "'s arbitrary precision numbers, hence there are still some possibilities \ that the result error bounds are wrong mathematically though they may be very \ rare cases. For this problem, we will prepare the option which can enable all \ computations in our package by interval arithmetic, since we have not been \ able to find enough informations about ", StyleBox["Mathematica", FontSlant->"Italic"], "'s arbitrary precision numbers and interval arithmetic is the only way to \ guarantee the result at this time." }], "Text"] }, Open ]], Cell[CellGroupData[{ Cell["Adding Precision Assurance for Some Built-in Functions", "Subsection"], Cell[TextData[{ "In our package, we have to compute singular values and matrix inverses \ with precision assurance. However, as in the previous section, we can not \ trust precision and accuracy of results by the built-in function ", ButtonBox["SingularValueList", ButtonStyle->"RefGuideLink"], ", ", ButtonBox["Inverse", ButtonStyle->"RefGuideLink"], " and so on. Fortunately, we have the following well-known corollary \ bounding errors of singular values (see Corollary 8.6.2 in [GL96])." }], "Text"], Cell[TextData[{ "For any matrices ", Cell[BoxData[ \(TraditionalForm\`A\)]], " and ", Cell[BoxData[ \(TraditionalForm\`E\)]], " in ", Cell[BoxData[ \(TraditionalForm\`\[DoubleStruckCapitalC]\^\(n\[Times]m\)\)]], " and any positive integer ", Cell[BoxData[ \(TraditionalForm\`k \[LessEqual] min {n, m}\)]], ", we have" }], "Text", CellMargins->{{36, Inherited}, {Inherited, Inherited}}], Cell[BoxData[ RowBox[{ "|", \(\(\[Sigma]\_k\) \((A + E)\) - \(\[Sigma]\_k\) \((A)\)\), "|", RowBox[{"\[LessEqual]", StyleBox["\[DoubleVerticalBar]", SpanMaxSize->Infinity], StyleBox["E", SpanMaxSize->Infinity], SubscriptBox[ StyleBox["\[DoubleVerticalBar]", SpanMaxSize->Infinity], \(\(\ \ \)\(2\)\)]}]}]], "DisplayFormula",\ CellMargins->{{36, Inherited}, {Inherited, Inherited}}], Cell[TextData[{ "where ", Cell[BoxData[ \(TraditionalForm\`\(\[Sigma]\_s\)(M)\)]], " and ", Cell[BoxData[ \(TraditionalForm\`\(\(\[DoubleVerticalBar]\)\(M\)\( \ \[DoubleVerticalBar] \_2\)\)\)]], " denote the ", Cell[BoxData[ \(TraditionalForm\`s\)]], "-th largest singular value and the 2-norm of ", Cell[BoxData[ \(TraditionalForm\`M\)]], ", respectively." }], "Text", CellMargins->{{36, Inherited}, {Inherited, Inherited}}], Cell["\<\ By this fact, we can get the smallest singular value and the matrix \ inverse with precision assurance as follows.\ \>", "Text"], Cell[TextData[{ "(step 1) compute singular values of ", Cell[BoxData[ \(TraditionalForm\`M\)]], " by the built-in function" }], "Text", CellMargins->{{27, Inherited}, {Inherited, Inherited}}], Cell["\<\ (step 2) convert these singular values and the elements of \ associated matrices to rational intervals\ \>", "Text", CellMargins->{{27, Inherited}, {Inherited, Inherited}}], Cell[TextData[{ "(step 3) compute the upper bound of 2-norm of the residual matrix of ", Cell[BoxData[ \(TraditionalForm\`M\)]] }], "Text", CellMargins->{{27, Inherited}, {Inherited, Inherited}}], Cell["\<\ (step 4) compute the rational intervals by the above corollary, and \ associated matrix inverse or pseudo inverse\ \>", "Text", CellMargins->{{27, Inherited}, {Inherited, Inherited}}], Cell["\<\ For example, we can use the following function instead of the \ built-in.\ \>", "Text"], Cell[BoxData[ \(SingularValueListWithErrorBound[inmtx_List /; ListQ[First[inmtx]], ineps_: Automatic] := Module[{eps, mtx, matU, matD, matV, matE, errB, sigma, i}, \[IndentingNewLine]If[NumberQ[ineps], eps = ineps, eps = MachinePrecision]; \[IndentingNewLine]If[eps === Infinity, eps = MachinePrecision]; If[eps < MachinePrecision, eps = MachinePrecision]; \[IndentingNewLine]mtx = SetPrecision[inmtx, eps]; \[IndentingNewLine]{matU, matD, matV} = SingularValueDecomposition[mtx]; \[IndentingNewLine]matU = Map[SNAPFloat2Rational, matU, {2}]; \[IndentingNewLine]matD = Map[SNAPFloat2Rational, matD, {2}]; \[IndentingNewLine]matV = Map[SNAPFloat2Rational, matV, {2}]; \[IndentingNewLine]matE = matU . matD . Transpose[Conjugate[matV]] - inmtx; \[IndentingNewLine]errB = Max[Sqrt[Plus @@ Flatten[Abs[matE]^2]]]; \[IndentingNewLine]sigma = Table[matD[\([i, i]\)], {i, 1, Length[First[matD]]}]; \[IndentingNewLine]sigma = Map[\((# + Interval[{\(-1\), 1}*errB])\) &, sigma]; \[IndentingNewLine]Return[ sigma];\[IndentingNewLine]]\)], "InputOnly"], Cell["\<\ We note that the above function does not work in this notebook \ since this function requires: 1) prepare complex interval arithmetic, 2) \ extend SNAPFloat2Rational to complex intervals and 3) extend Conjugate to \ complex intervals. Those requirements are implemented in our package, \ however, we can not copy them here due to the page limit.\ \>", "Text"] }, Open ]] }, Open ]], Cell[CellGroupData[{ Cell["References", "Section"], Cell["\<\ [Fateman92] Fateman, R. J., A review of Mathematica, J. Symbolic \ Comput. 13, 1992, 545-579.\ \>", "Reference"], Cell["\<\ [GL96] Golub, G. H. and Loan, C. F. V., Matrix Computations Third \ Edition, Johns Hopkins Series in the Mathematical Sciences. The Johns Hopkins \ University Press, Baltimore, 1996.\ \>", "Reference"], Cell["\<\ [KN05] Nagasaka, K., SNAP, International Mathematica Symposium, IMS \ 2005, 5-8th August 2005.\ \>", "Reference"], Cell["\<\ [SS05] Sofroniou, M. and Spaletta, G., Precise Numerical \ Computation, Journal of Logic and Algebraic Programming 64(1), 2005, 113-134.\ \ \>", "Reference"], Cell[TextData[{ "[Trott05] Trott, M., The ", StyleBox["Mathematica", FontSlant->"Italic"], " Guide Book for Numerics, Springer, 2005." }], "Reference"] }, Open ]] }, Open ]] }, FrontEndVersion->"5.2 for X", ScreenRectangle->{{0, 1920}, {0, 1200}}, WindowToolbars->{"RulerBar", "EditBar"}, WindowSize->{1016, 894}, WindowMargins->{{37, Automatic}, {Automatic, 26}}, PrintingPageRange->{Automatic, Automatic}, PageHeaders->{{ Inherited, Inherited, Cell[ "Kosaku Nagasaka", "Header"]}, { Cell[ "Mathematical Issues of Mathematica's BigFloat and Our Resolutions \ in SNAP Package", "Header"], Inherited, Inherited}}, PrintingOptions->{"PaperSize"->{612, 792}, "PaperOrientation"->"Portrait", "PostScriptOutputFile":>FrontEnd`FileName[{$RootDirectory, "home", "papegay", \ "ims06", "eproc", "articles"}, "Nagasaka.nb.ps", CharacterEncoding -> \ "iso8859-1"], "Magnification"->1}, Magnification->1, StyleDefinitions -> "IMS2006styles.nb" ] (******************************************************************* 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->{ "Info3351452680-1623943"->{ Cell[34660, 1089, 413, 10, 41, "Print", CellTags->"Info3351452680-1623943"]}, "Info3351452686-9513144"->{ Cell[35204, 1108, 416, 10, 41, "Print", CellTags->"Info3351452686-9513144"]} } *) (*CellTagsIndex CellTagsIndex->{ {"Info3351452680-1623943", 89780, 2760}, {"Info3351452686-9513144", 89898, 2763} } *) (*NotebookFileOutline Notebook[{ Cell[CellGroupData[{ Cell[1776, 53, 161, 5, 125, "Title"], Cell[1940, 60, 33, 0, 22, "Author"], Cell[1976, 62, 86, 3, 43, "TextAboutAuthor"], Cell[2065, 67, 885, 22, 124, "Abstract"], Cell[CellGroupData[{ Cell[2975, 93, 36, 0, 62, "SectionFirst"], Cell[3014, 95, 2075, 42, 188, "Text"], Cell[5092, 139, 195, 4, 26, "Text"] }, Open ]], Cell[CellGroupData[{ Cell[5324, 148, 37, 0, 62, "Section"], Cell[5364, 150, 445, 12, 44, "Text"], Cell[CellGroupData[{ Cell[5834, 166, 105, 5, 54, "Subsection"], Cell[5942, 173, 608, 17, 62, "Text"], Cell[6553, 192, 333, 8, 44, "Text"], Cell[CellGroupData[{ Cell[6911, 204, 47, 0, 42, "Subsubsection"], Cell[6961, 206, 331, 12, 26, "Text"], Cell[7295, 220, 607, 12, 78, "Text"], Cell[7905, 234, 1749, 57, 60, "Text"], Cell[9657, 293, 376, 7, 77, "InputOnly"], Cell[10036, 302, 127, 4, 39, "Caption"], Cell[10166, 308, 877, 28, 62, "Text"], Cell[11046, 338, 419, 11, 55, "NumberedEquation"], Cell[11468, 351, 504, 15, 55, "NumberedEquation"], Cell[11975, 368, 493, 18, 44, "Text"], Cell[CellGroupData[{ Cell[12493, 390, 143, 3, 40, "Input"], Cell[12639, 395, 65, 2, 41, "Output"] }, Open ]], Cell[CellGroupData[{ Cell[12741, 402, 143, 3, 40, "Input"], Cell[12887, 407, 78, 2, 41, "Output"] }, Open ]], Cell[CellGroupData[{ Cell[13002, 414, 86, 2, 40, "Input"], Cell[13091, 418, 84, 2, 41, "Output"] }, Open ]], Cell[CellGroupData[{ Cell[13212, 425, 86, 2, 40, "Input"], Cell[13301, 429, 84, 2, 41, "Output"] }, Open ]] }, Open ]], Cell[CellGroupData[{ Cell[13434, 437, 46, 0, 42, "Subsubsection"], Cell[13483, 439, 459, 15, 44, "Text"], Cell[13945, 456, 529, 11, 60, "Text"], Cell[14477, 469, 330, 7, 44, "Text"] }, Open ]], Cell[CellGroupData[{ Cell[14844, 481, 66, 0, 42, "Subsubsection"], Cell[14913, 483, 664, 16, 62, "Text"] }, Open ]] }, Open ]], Cell[CellGroupData[{ Cell[15626, 505, 134, 5, 54, "Subsection"], Cell[15763, 512, 584, 12, 62, "Text"], Cell[CellGroupData[{ Cell[16372, 528, 47, 0, 42, "Subsubsection"], Cell[16422, 530, 316, 8, 44, "Text"], Cell[16741, 540, 837, 25, 60, "Text"], Cell[17581, 567, 632, 15, 62, "Text"], Cell[18216, 584, 400, 10, 44, "Text"], Cell[18619, 596, 1208, 39, 80, "Text"], Cell[19830, 637, 424, 9, 62, "Text"] }, Open ]], Cell[CellGroupData[{ Cell[20291, 651, 46, 0, 42, "Subsubsection"], Cell[20340, 653, 270, 9, 26, "Text"], Cell[20613, 664, 727, 18, 78, "Text"], Cell[21343, 684, 653, 13, 80, "Text"], Cell[21999, 699, 277, 6, 42, "Text"], Cell[22279, 707, 601, 11, 62, "Text"], Cell[22883, 720, 864, 24, 64, "Text"], Cell[23750, 746, 1374, 45, 67, "Text"], Cell[25127, 793, 247, 4, 25, "DisplayFormula"], Cell[25377, 799, 308, 9, 26, "Text"], Cell[25688, 810, 168, 2, 25, "DisplayFormula"], Cell[25859, 814, 754, 17, 80, "Text"], Cell[26616, 833, 377, 7, 44, "Text"], Cell[26996, 842, 638, 13, 96, "Text"], Cell[27637, 857, 544, 13, 62, "Text"] }, Open ]], Cell[CellGroupData[{ Cell[28218, 875, 66, 0, 42, "Subsubsection"], Cell[28287, 877, 408, 12, 44, "Text"], Cell[28698, 891, 555, 11, 60, "Text"], Cell[29256, 904, 352, 8, 60, "Text"], Cell[29611, 914, 688, 24, 42, "Text"], Cell[30302, 940, 148, 3, 26, "Text"], Cell[CellGroupData[{ Cell[30475, 947, 90, 2, 40, "Input"], Cell[30568, 951, 388, 6, 73, "Output"] }, Open ]], Cell[CellGroupData[{ Cell[30993, 962, 90, 2, 40, "Input"], Cell[31086, 966, 493, 7, 89, "Output"] }, Open ]], Cell[CellGroupData[{ Cell[31616, 978, 90, 2, 40, "Input"], Cell[31709, 982, 607, 9, 105, "Output"] }, Open ]] }, Open ]], Cell[CellGroupData[{ Cell[32365, 997, 38, 0, 42, "Subsubsection"], Cell[32406, 999, 121, 3, 26, "Text"], Cell[32530, 1004, 546, 14, 78, "Text"], Cell[33079, 1020, 68, 0, 26, "Text"], Cell[CellGroupData[{ Cell[33172, 1024, 88, 2, 40, "Input"], Cell[33263, 1028, 63, 2, 41, "Output"] }, Open ]], Cell[CellGroupData[{ Cell[33363, 1035, 89, 2, 40, "Input"], Cell[33455, 1039, 64, 2, 41, "Output"] }, Open ]], Cell[CellGroupData[{ Cell[33556, 1046, 91, 2, 40, "Input"], Cell[33650, 1050, 63, 2, 41, "Output"] }, Open ]], Cell[33728, 1055, 552, 14, 62, "Text"], Cell[CellGroupData[{ Cell[34305, 1073, 120, 3, 40, "Input"], Cell[34428, 1078, 101, 2, 41, "Output"] }, Open ]], Cell[CellGroupData[{ Cell[34566, 1085, 91, 2, 40, "Input"], Cell[34660, 1089, 413, 10, 41, "Print", CellTags->"Info3351452680-1623943"] }, Open ]], Cell[CellGroupData[{ Cell[35110, 1104, 91, 2, 40, "Input"], Cell[35204, 1108, 416, 10, 41, "Print", CellTags->"Info3351452686-9513144"] }, Open ]] }, Open ]] }, Open ]], Cell[CellGroupData[{ Cell[35681, 1125, 29, 0, 54, "Subsection"], Cell[35713, 1127, 549, 10, 62, "Text"], Cell[36265, 1139, 865, 19, 80, "Text"] }, Open ]] }, Open ]], Cell[CellGroupData[{ Cell[37179, 1164, 48, 0, 62, "Section"], Cell[37230, 1166, 204, 4, 44, "Text"], Cell[CellGroupData[{ Cell[37459, 1174, 44, 0, 54, "Subsection"], Cell[37506, 1176, 194, 6, 26, "Text"], Cell[37703, 1184, 561, 14, 62, "Text"], Cell[CellGroupData[{ Cell[38289, 1202, 196, 4, 40, "Input"], Cell[38488, 1208, 793, 12, 89, "Output"] }, Open ]], Cell[39296, 1223, 262, 5, 44, "Text"], Cell[CellGroupData[{ Cell[39583, 1232, 181, 4, 40, "Input"], Cell[39767, 1238, 88, 2, 41, "Output"] }, Open ]], Cell[CellGroupData[{ Cell[39892, 1245, 181, 4, 40, "Input"], Cell[40076, 1251, 88, 2, 41, "Output"] }, Open ]], Cell[CellGroupData[{ Cell[40201, 1258, 904, 23, 56, "Input"], Cell[41108, 1283, 288, 9, 41, "Output"] }, Open ]], Cell[CellGroupData[{ Cell[41433, 1297, 904, 23, 56, "Input"], Cell[42340, 1322, 288, 9, 41, "Output"] }, Open ]], Cell[42643, 1334, 257, 6, 26, "Text"], Cell[CellGroupData[{ Cell[42925, 1344, 196, 5, 40, "Input"], Cell[43124, 1351, 310, 5, 57, "Output"] }, Open ]], Cell[43449, 1359, 934, 30, 62, "Text"], Cell[CellGroupData[{ Cell[44408, 1393, 94, 2, 40, "Input"], Cell[44505, 1397, 401, 6, 73, "Output"] }, Open ]], Cell[CellGroupData[{ Cell[44943, 1408, 77, 2, 40, "Input"], Cell[45023, 1412, 76, 2, 41, "Output"] }, Open ]], Cell[CellGroupData[{ Cell[45136, 1419, 78, 2, 40, "Input"], Cell[45217, 1423, 59, 2, 41, "Output"] }, Open ]], Cell[45291, 1428, 115, 3, 26, "Text"], Cell[45409, 1433, 201, 4, 42, "DisplayFormula"], Cell[45613, 1439, 268, 11, 26, "Text"] }, Open ]], Cell[CellGroupData[{ Cell[45918, 1455, 43, 0, 54, "Subsection"], Cell[45964, 1457, 1094, 39, 62, "Text"], Cell[47061, 1498, 168, 2, 25, "DisplayFormula"], Cell[47232, 1502, 244, 8, 26, "Text"], Cell[47479, 1512, 118, 3, 67, "InputOnly"], Cell[47600, 1517, 1466, 46, 62, "Text"], Cell[49069, 1565, 357, 6, 115, "InputOnly"], Cell[49429, 1573, 597, 20, 44, "Text"], Cell[50029, 1595, 410, 10, 83, "InputOnly"], Cell[50442, 1607, 41, 0, 26, "Text"], Cell[50486, 1609, 157, 4, 51, "InputOnly"], Cell[CellGroupData[{ Cell[50668, 1617, 195, 4, 40, "Input"], Cell[50866, 1623, 1305, 36, 95, "Output"] }, Open ]], Cell[52186, 1662, 690, 20, 62, "Text"], Cell[52879, 1684, 274, 9, 26, "Text"], Cell[CellGroupData[{ Cell[53178, 1697, 774, 16, 188, "Input"], Cell[53955, 1715, 1358, 38, 95, "Output"] }, Open ]] }, Open ]], Cell[CellGroupData[{ Cell[55362, 1759, 63, 0, 54, "Subsection"], Cell[55428, 1761, 203, 4, 44, "Text"], Cell[CellGroupData[{ Cell[55656, 1769, 71, 2, 40, "Input"], Cell[55730, 1773, 194, 6, 41, "Output"] }, Open ]], Cell[CellGroupData[{ Cell[55961, 1784, 136, 3, 40, "Input"], Cell[56100, 1789, 15022, 451, 137, "Output"] }, Open ]], Cell[71137, 2243, 629, 10, 80, "Text"], Cell[CellGroupData[{ Cell[71791, 2257, 223, 6, 40, "Input"], Cell[72017, 2265, 2023, 34, 153, "Output"] }, Open ]] }, Open ]], Cell[CellGroupData[{ Cell[74089, 2305, 29, 0, 54, "Subsection"], Cell[74121, 2307, 498, 8, 62, "Text"] }, Open ]] }, Open ]], Cell[CellGroupData[{ Cell[74668, 2321, 33, 0, 62, "Section"], Cell[74704, 2323, 475, 8, 62, "Text"], Cell[75182, 2333, 104, 3, 26, "Text"], Cell[75289, 2338, 197, 6, 26, "Text"], Cell[75489, 2346, 183, 6, 26, "Text"], Cell[75675, 2354, 65, 0, 26, "Text"], Cell[75743, 2356, 169, 4, 26, "Text"], Cell[CellGroupData[{ Cell[75937, 2364, 71, 0, 54, "Subsection"], Cell[76011, 2366, 639, 15, 62, "Text"], Cell[76653, 2383, 561, 14, 62, "Text"], Cell[77217, 2399, 192, 5, 51, "InputOnly"], Cell[77412, 2406, 252, 6, 67, "InputOnly"], Cell[77667, 2414, 143, 3, 51, "InputOnly"], Cell[77813, 2419, 151, 3, 51, "InputOnly"], Cell[77967, 2424, 498, 12, 62, "Text"], Cell[78468, 2438, 240, 5, 44, "Text"], Cell[78711, 2445, 362, 8, 67, "InputOnly"], Cell[79076, 2455, 187, 4, 51, "InputOnly"], Cell[79266, 2461, 132, 3, 26, "Text"], Cell[79401, 2466, 1019, 21, 211, "InputOnly"], Cell[CellGroupData[{ Cell[80445, 2491, 222, 4, 40, "Input"], Cell[80670, 2497, 1609, 44, 113, "Output"] }, Open ]], Cell[82294, 2544, 676, 13, 80, "Text"] }, Open ]], Cell[CellGroupData[{ Cell[83007, 2562, 76, 0, 54, "Subsection"], Cell[83086, 2564, 521, 11, 62, "Text"], Cell[83610, 2577, 429, 15, 26, "Text"], Cell[84042, 2594, 468, 12, 24, "DisplayFormula"], Cell[84513, 2608, 469, 16, 26, "Text"], Cell[84985, 2626, 138, 3, 26, "Text"], Cell[85126, 2631, 205, 6, 26, "Text"], Cell[85334, 2639, 184, 4, 26, "Text"], Cell[85521, 2645, 207, 5, 26, "Text"], Cell[85731, 2652, 195, 4, 26, "Text"], Cell[85929, 2658, 97, 3, 26, "Text"], Cell[86029, 2663, 1265, 21, 275, "InputOnly"], Cell[87297, 2686, 369, 6, 62, "Text"] }, Open ]] }, Open ]], Cell[CellGroupData[{ Cell[87715, 2698, 29, 0, 62, "Section"], Cell[87747, 2700, 122, 3, 22, "Reference"], Cell[87872, 2705, 211, 4, 22, "Reference"], Cell[88086, 2711, 123, 3, 22, "Reference"], Cell[88212, 2716, 167, 4, 22, "Reference"], Cell[88382, 2722, 161, 5, 22, "Reference"] }, Open ]] }, Open ]] } ] *) (******************************************************************* End of Mathematica Notebook file. *******************************************************************)