(************** Content-type: application/mathematica **************
                     CreatedBy='Mathematica 5.0'

                    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[     19462,        524]*)
(*NotebookOutlinePosition[     20106,        546]*)
(*  CellTagsIndexPosition[     20062,        542]*)
(*WindowFrame->Normal*)



Notebook[{
Cell[BoxData[
    \(M\  = \ {\ {1, 2, 3}, \ {4, 5, 6}, \ {0, 8, 9}}\)], "Input"],

Cell[BoxData[
    \("\<Putting stuff in quotes allows you to write comments. The above is \
how you define a 3x3 matrix. Below is how to view it as a matrix. To compile \
a line, you need to press SHIFT-ENTER. Do not compile the instruction \
lines.\>"\)], "Input"],

Cell[BoxData[
    \(MatrixForm[M]\)], "Input"],

Cell[BoxData[
    \(M2\  = \ M . M\)], "Input"],

Cell[BoxData[
    \("\<The above multiplies two matrices. We'll now calculate some basic \
quantities.\>"\)], "Input"],

Cell[BoxData[
    \(InvM\  = \ Inverse[M]\)], "Input"],

Cell[BoxData[
    \(c\  = \ Eigenvalues[M]\)], "Input"],

Cell[BoxData[
    \("\<On some versions of mathematica, when you compile the above it gives \
Root[blah]. This is because the answer is 
not exact. To get an exact answer, we use the Numerical Command, N. We first \
give an example. If we type Pi, we get the exact
answer (a symbol). If we type N[Pi], it gives us a few digits. If we need \
more digits, do N[Pi,numdigitsneed]\>"\)], "Input"],

Cell[BoxData[
    \(Pi\)], "Input"],

Cell[BoxData[
    \(N[Pi]\)], "Input"],

Cell[BoxData[
    \(N[Pi, \ 20]\)], "Input"],

Cell[BoxData[
    \(c\  = \ N[\ Eigenvalues[M], \ 10\ ]\)], "Input"],

Cell[BoxData[
    \("\<Notice we now have numerical values of the eigenvalues (to 10 \
digits). These values are stored, and we can pull off entries
one at a time.\>"\)], "Input"],

Cell[BoxData[
    \(c[\([1]\)]\)], "Input"],

Cell[BoxData[
    \(N[\ c[\([1]\)]\ ]\)], "Input"],

Cell[BoxData[
    \("\<Note how we were able to store the eigenvalues in a vector, and then \
read off the components. Sometimes we need single brackets, sometimes we need \
double brackets.
Using N[ ... ] gives numerical values.\>"\)], "Input"],

Cell[BoxData[
    \(MM\  = \ Table[Random[], \ {m, 4}, \ {n, \ 4}]\)], "Input"],

Cell[BoxData[
    \(MatrixForm[MM]\)], "Input"],

Cell[BoxData[
    \("\<The above generates a random 4x4 matrix with entries chosen from the \
uniform distribution.\>"\)], "Input"],

Cell[BoxData[
    \("\<We now load in a package, the statistical package on Continuous \
Distributions. It has a lot of nice distributions,
for example, the Gaussian distribution. we will save the Gaussian \
distribution to the name gdist.\>"\)], "Input"],

Cell[BoxData[
    \(<< Statistics`ContinuousDistributions`\)], "Input"],

Cell[BoxData[
    \(gdist\  = \ NormalDistribution[0, 1]\)], "Input"],

Cell[BoxData[
    \(NN\  = \ 
      MatrixForm[\ \ Table[
          Random[gdist], \ {m, \ 4}, \ {n, 4}\ ]\ \ ]\)], "Input"],

Cell[BoxData[
    \("\<This allows us to load in a statistics package and generate matrices \
with entries from a normal distribution. Watch what happens to the entries as \
we change the standard deviation.\>"\)], "Input"],

Cell[BoxData[
    \(gdist2\  = \ NormalDistribution[0, 10]\)], "Input"],

Cell[BoxData[
    \(NN\  = \ 
      MatrixForm[\ \ Table[
          Random[gdist2], \ {m, 4}, \ {n, 4}\ ]\ \ ]\)], "Input"],

Cell[BoxData[
    \(Det[NN]\)], "Input"],

Cell[BoxData[
    \("\<Notice we do NOT get the determinant. The problem is that NN is NOT \
a matrix, but a DISPLAYED matrix.\>"\)], "Input"],

Cell[BoxData[
    \(NNN\  = \ Table[Random[gdist2], \ {m, 4}, \ {n, 4}\ ]\)], "Input"],

Cell[BoxData[
    \(Det[NNN]\)], "Input"],

Cell[BoxData[
    \("\<To define a function, one needs to do an underscore after each \
variable, and := instead of =\>"\)], "Input"],

Cell[BoxData[
    \(f[x_, y_, z_]\  := \ Sin[x\  + \ y]\ *\ z^2\)], "Input"],

Cell[BoxData[
    \(f[1, 2, 3]\)], "Input"],

Cell[BoxData[
    \("\<To get numerical values, one can use 1.0 instead of 1\>"\)], "Input"],

Cell[BoxData[
    \(f[1.0, 2, 3]\)], "Input"],

Cell[BoxData[
    \(g[n_]\  := \ Prime[n]\)], "Input"],

Cell[BoxData[{
    \(g[2]; \ \ g[3]\ \ \), "\[IndentingNewLine]", 
    \(g[4]\)}], "Input"],

Cell[BoxData[
    \("\<you can do multiple statements on one line if you separate with a \
semi-colon. Only the output of the last is displayed. Here, g[n] is the nth \
prime number.\>"\)], "Input"],

Cell[BoxData[
    \(G[x_]\  := \ Sum[\ n, \ {n, 1, Floor[x]}]\)], "Input"],

Cell[BoxData[
    \(Plot[\ G[x], \ {x, 1, 10}]\)], "Input"],

Cell[BoxData[
    \("\<You can also plot several functions at once.\>"\)], "Input"],

Cell[BoxData[
    \(Plot[\ {G[x], \  .5*x\ *\ \((x + 1)\)\  + \ 0*\ x*Sin[6\ x]}, \ {x, \ 
        1, \ 25}\ ]\)], "Input"],

Cell[BoxData[
    \("\<Mathematica also supports IF and FOR statements\>"\)], "Input"],

Cell[BoxData[
    \(Mod[12, 7]\)], "Input"],

Cell[BoxData[
    \("\<The above is the mod function: 12 mod 7 is 5\>"\)], "Input"],

Cell[BoxData[
    \(h[x_]\  := \ 
      If[\ Mod[\ Floor[x], \ 2]\  \[Equal] \ 1, \ 5, \ \(-5\)]\)], "Input"],

Cell[BoxData[
    \(Plot[\ h[x], \ {x, \(-5\), 5}]\)], "Input"],

Cell[BoxData[
    \("\<If statements work by IF[Condition, Then This, Else This]. You can \
have nested IF statements\>"\)], "Input"],

Cell[BoxData[
    \(h[x_]\  := \ 
      If[\ Mod[\ Floor[x], \ 3]\  \[Equal] \ 0, \ 
        0, \ \[IndentingNewLine]\t\t\ \ \ \ \ \ If[\ 
          Mod[\ Floor[x], \ 3]\  \[Equal] \ 1, \ 1, \ 
          2]\[IndentingNewLine]\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \
]\)], "Input"],

Cell[BoxData[
    \(Plot[\ h[x], \ {x, 0, 9}]\)], "Input"],

Cell[BoxData[{
    \(Start = \ 57614; \ Num\  = \ 480000; \ 
    theModulus\  = \ 210;\), "\[IndentingNewLine]", 
    \(\(For[i\  = \ 0, \ 
        i\ \  \[LessEqual] \ \ theModulus\  + \ 2, \ \(i++\), \ 
        NumMod[i\ ]\  = \ 0\ \ ];\)\), "\[IndentingNewLine]", 
    \(\(For[k = Start, \ 
        k \[LessEqual] \ 
          Start + Num, \ \(k++\), \[IndentingNewLine]\ \ \(NumMod[\ \ Mod[
              Prime[k], \ 
              theModulus\ ]\ ]++\)\ ];\)\), "\[IndentingNewLine]", 
    \(temp\  = \ 
      Table[\ {k, \ NumMod[k]}, \ {k, 1, \ 
          theModulus\  - \ 1}]\), "\[IndentingNewLine]", 
    \(ListPlot[\ temp\ ]\), "\[IndentingNewLine]", 
    \(\(F[x_]\  := \ 
        NumMod[\ Mod[Floor[x], \ theModulus]\ ];\)\), "\[IndentingNewLine]", 
    \(Plot[\ 
      F[x], \ {x, 1, theModulus -  .000001}]\), "\[IndentingNewLine]", 
    \(Plot[\ {F[x], \ \((Num*1.0\ \  + \ Sqrt[1.0*Num])\)\ /\ 
          EulerPhi[
            theModulus], \[IndentingNewLine]\ \ \ \ \ \ \ \ \((Num*1.0\ \  - \
\ Sqrt[1.0*Num])\)\ /\ EulerPhi[theModulus]}, \ {x, 1, 
        theModulus -  .000001}]\)}], "Input"],

Cell[BoxData[
    \(EulerPhi[210]\)], "Input"],

Cell[BoxData[
    \("\<The EulerPhi function gives the number of numbers relatively prime \
to n.\>"\)], "Input"],

Cell[BoxData[
    \("\<Note above that graphs / plots without a ; at the end are displayed.\
\>"\)], "Input"],

Cell[BoxData[
    \(G[4]\)], "Input"],

Cell[BoxData[
    \(IntegerQ[Sqrt[21222079685]]\)], "Input"],

Cell[BoxData[
    \(145678*145678\)], "Input"],

Cell[BoxData[
    \(\(temp2\  = \ 
        Table[\ If[
            NumMod[k]\  > \ 0, \ {k, \ NumMod[k]}, \ {k, \ 
              Num\ /\ EulerPhi[theModulus]}], \ \ {k, 1, \ 
            theModulus\  - \ 1}];\)\)], "Input"],

Cell[BoxData[{
    \(\(F[x_]\  := \ 
        NumMod[\ Mod[Floor[x], \ theModulus]\ ];\)\), "\[IndentingNewLine]", 
    \(Plot[\ {F[x], \ \((Num*1.0\ \  + \ Sqrt[1.0*Num])\)\ /\ 
          EulerPhi[
            theModulus], \[IndentingNewLine]\ \ \ \ \ \ \ \ \((Num*1.0\ \  - \
\ Sqrt[1.0*Num])\)\ /\ EulerPhi[theModulus]}, \ {x, 1, 
        theModulus -  .000001}]\)}], "Input"],

Cell[BoxData[
    \(plot1\  = \ ListPlot[\ temp2]\)], "Input"],

Cell[BoxData[""], "Input"],

Cell[BoxData[
    \(\(temphigh\  = \ 
        Table[\ {k, \ \((Num*1.0\ \  + \ Sqrt[1.0*Num])\)\ /\ 
              EulerPhi[theModulus]}, \ {k, 1, \ 
            theModulus\  - \ 1}];\)\)], "Input"],

Cell[BoxData[
    \(\(templow\  = \ \ Table[\ {k, \ \((Num*1.0\ \  - \ Sqrt[1.0*Num])\)\ /\ 
              EulerPhi[theModulus]}, \ {k, 1, \ 
            theModulus\  - \ 1}];\)\)], "Input"],

Cell[BoxData[
    \(plot2\  = \ ListPlot[\ temphigh\ ]; \ 
    plot3\  = \ ListPlot[\ templow]\)], "Input"],

Cell[BoxData[
    \(\(\(\[IndentingNewLine]\)\(\[IndentingNewLine]\)\(\[IndentingNewLine]\)\
\(\[IndentingNewLine]\)\)\)], "Input"],

Cell[BoxData[
    \("\<We now include a quick program to calculate eigenvalues of Toeplitz \
Matrices. This code can easily be 
modified for other investigations.\>"\)], "Input"],

Cell[BoxData[
    \("\<First we make sure we have loaded in the packages we need.\>"\)], \
"Input"],

Cell[BoxData[
    \(<< Graphics`Graphics`\)], "Input"],

Cell[BoxData[{
    \(<< Statistics`DataManipulation`\), "\[IndentingNewLine]", 
    \(<< Statistics`NormalDistribution`\)}], "Input"],

Cell[BoxData[
    \(\(\(ndist\  = \ NormalDistribution[0, 1];\)\(\ \)\)\)], "Input"],

Cell[BoxData[
    \("\<In the program below, we calculate num matrices, each is n x n. we \
choose the entries randomly from the standard normal
distribution subject to being a real symmetric toeplitz matrix with zeros on \
the main diagonal. we normalize the eigenvalues by
sqrt[n]. we also have some if statements that print based on where we are -- \
the point is to know how much longer the program
will have to run. we then create a histogram.\>"\)], "Input"],

Cell[BoxData[
    \(\(TopMatnodiag[n_, \ num_]\  := \ 
        Module[\ {aa, \ b}, \ \[IndentingNewLine]\ \ \ \ \ \ \ \ Clear[
            temp]; \[IndentingNewLine]\ \ \ \ \ \ \ \ temp\  = \ {}; \
\[IndentingNewLine]\ \ \ \ \ \ \ \ For[aa\  = \ 1, \ 
            aa\  \[LessEqual] \ 
              num, \ \(aa++\), \[IndentingNewLine]\ \ \ \ \ \ \ \ \ \ \ \ \ \ \
\ \ \ \ \ \ {\[IndentingNewLine]\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \
\ \ \ \ \ \ \ \ \ \ Clear[a]; \[IndentingNewLine]\t\t\t\ \ \ \ \ \ For[
                i\  = \ 1, \ i\  \[LessEqual] \ n, \ \(i++\), \ 
                a[i, i]\  = \ 0]; \ \ \  (*\ 
                zero\ *) \[IndentingNewLine]\t\t\t\ \ \ \ \ \ For[
                k\  = \ 2, \ 
                k\  \[LessEqual] \ 
                  n, \ \(k++\), \[IndentingNewLine]\ \ \ \ \ \ \ \ \ \ \ \ \ \
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ ran1\  = \ 
                  Random[ndist]\ ; \[IndentingNewLine]\t\t\t\t\ \ \ \ \ \ \ \
For[i = 1, \ i\  \[LessEqual] \ 
                    n\  - \ k\  + \ 
                      1, \ \(i++\), \[IndentingNewLine]\ \ \ \ \ \ \ \ \ \ \ \
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \
\ \ \ \ {\ \(a[\ i, \ k\  - 1\  + \ i]\  = \ \ \(a[
                            k\ \  - \ 1\  + \ i, \ \ i]\  = \ 
                          ran1\);\)\ \ \ }\ \ \[IndentingNewLine]\t\t\t\t\ \ \
\ \ \ \ \ \ \ \ \ \ ];\[IndentingNewLine]\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ ]\ ; \[IndentingNewLine]\ \ \ \ \ \
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ mat\  = \ 
                Array[\ a, \ {n, 
                    n}]; \[IndentingNewLine]\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ tempev\  = \ \ N[
                  Eigenvalues[mat]\ /\ 
                    Sqrt[1.0*
                        n]]\ ; \[IndentingNewLine]\ \ \ \ \ \ \ \ \ \ \ \ \ \ \
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ If[\ Mod[aa, \ 20]\  \[Equal] \ 0, \ 
                Print["\<We're at aa = \>", \ 
                  aa]]; \[IndentingNewLine]\t\t\t\ \ \ \ \ \ For[b\  = \ 1, \ 
                b \[LessEqual] \ 
                  n, \ \(b++\), \ \(temp\  = \ 
                    Append[\ temp, \ 
                      tempev[\([b]\)]\ ]\ ;\)\ \ ];\[IndentingNewLine]\ \ \ \ \
\ \ \ \ \ \ \ \ \ \ \ \ \ }\[IndentingNewLine]\ \ \ \ \ \ \ \ \ \ \ \ \ ]; \
\[IndentingNewLine]\ 
          Histogram[\ temp\ ]; \ \[IndentingNewLine] (*\ 
            the\ second\ line\ scales\ the\ histogram\ so\ that\ we\ have\ \
percents\ and\ not\ total\ numbers\ *) \[IndentingNewLine]Histogram[temp, \ 
            HistogramCategories\  \[Rule] \ bincat, \ 
            HistogramScale\  \[Rule] \ 
              1];\[IndentingNewLine]\ \ ];\)\)], "Input"],

Cell[BoxData[
    \(TopMatnodiag[10, 100]\)], "Input"],

Cell[BoxData[
    \(\(\(\[IndentingNewLine]\)\(\[IndentingNewLine]\)\(\[IndentingNewLine]\)\
\(\[IndentingNewLine]\)\(\[IndentingNewLine]\)\(\[IndentingNewLine]\)\(\
\[IndentingNewLine]\)\(\[IndentingNewLine]\)\)\)], "Input"],

Cell[BoxData[
    \("\<Below is some code for investigating 3x+1 and its generalizations\>"\
\)], "Input"],

Cell[BoxData[
    \(RemoveTwo[x_]\  := \ 
      Module[{i}, \ i\  = \ x; \ 
        While[\ \ Mod[i, 2]\  \[Equal] \ 0, \ i\  = \ i\ /\ 2]; \ 
        Return[i]]\)], "Input"],

Cell[BoxData[{
    \(\(F3[x_]\  := \ 
        RemoveTwo[\ 3*RemoveTwo[x]\  + \ 1];\)\), "\[IndentingNewLine]", 
    \(\(F5[x_]\  := \ RemoveTwo[\ 5*RemoveTwo[x]\  + \ 1];\)\)}], "Input"],

Cell[BoxData[
    \("\<We now give a code to check the first digits of the 3x+1 \
problem\>"\)], "Input"],

Cell[BoxData[
    \(\(ben3[start_, \ num_]\  := \ 
        Module[\ {d, m, j, x}, \[IndentingNewLine]For[m = 1, \ 
            m \[LessEqual] \ 9, \ \(m++\), \ 
            numdig[m]\  = \ 0]; \[IndentingNewLine]x\  = \ 
            start; \[IndentingNewLine]count\  = \ 0; \[IndentingNewLine]For[
            j\  = \ 1, \ 
            j\  \[LessEqual] \ 
              num, \ \(j++\), \[IndentingNewLine]{\[IndentingNewLine] (*\ \
\(Print["\<x = \>", \ x, \ "\< at j = \>", \ 
                    j];\)\ *) \[IndentingNewLine]\(numdig[\ \ \ Mod[\ \ Floor[
                      x*1.0\ /\ 10^Floor[Log\ [10, \ x]]\ ], \ 
                    10\ ]\ ]++\); \[IndentingNewLine]count\  = \ 
                count + 1; \[IndentingNewLine]x\  = \ 
                F3[x]; \[IndentingNewLine]If[x\  \[Equal] \ 1, \ 
                j\  = \ num\  + \ 
                    5];\[IndentingNewLine]}]; \[IndentingNewLine]bF[
              y_]\  := \ numdig[Floor[y\  + \  .5]]\ /
              count; \[IndentingNewLine]ben[y_]\  := \ 
            Log[10, \ 
              1\  + \ \((1.0/y)\)]; \[IndentingNewLine]Plot[\ {bF[y], \ 
              ben[y]}, \ {y,  .5, 
              9.5}]; \[IndentingNewLine]Print["\<Count (the number of terms \
before we hit one) = \>", \ 
            count]; \[IndentingNewLine]Print["\<The number is approximately \
10^\>", \ Floor[Log[10, 1.0\ start]]];\[IndentingNewLine]];\)\)], "Input"],

Cell[BoxData[
    \(ben3[
      454353466457645775463645646475438578437598768493763984764983769837445745\
7745, 1000]\)], "Input"],

Cell[BoxData[
    \("\<The following compares the terms of 5x+1 to a geometric brownian \
motion and the first digits of the
terms to Benford's law.\>"\)], "Input"],

Cell[BoxData[
    \(glog[x_, \ end_]\  := \ 
      Module[\ {numat, \ tempplot, \ numdig, \ lognumdig, \ m, y, \ 
          temp}, \[IndentingNewLine]Clear[tempplot]; \ 
        Clear[temp]; \[IndentingNewLine]For[m\  = \ 1, \ 
          m\  \[LessEqual] \ 9, \ \(m++\), \ {\ lognumdig[m]\  = \ 0; \ 
            numdig[m]\  = \ 
              0;\ }\ ]; \[IndentingNewLine]tempplot\  = \ {\ {0, 
              0}\ }; \[IndentingNewLine]numat\  = \ 
          RemoveTwo[x]; \ \[IndentingNewLine]\ \ \ \ For[j = \ 1, \ 
            j\  \[LessEqual] \ 
              end, \ \ \(j++\), \ \[IndentingNewLine]\ \ \ \ \ \ {\ \ \
\[IndentingNewLine]If[\ 
                Mod[j, \ 1000]\  \[Equal] \ 
                  0, \ \(Print["\<j = \>", \ j, \ "\< x = \>", \ 
                    numat, \ "\< and goes to \>", \ 
                    F[numat]];\)\ ]; \[IndentingNewLine]AppendTo[\ 
                tempplot, \ {j, \ 
                  Log[E, numat]}\ ]; \[IndentingNewLine]AppendTo[\ 
                tempplot, \ \ {j, \ 
                  Log[E, \ 1.25]\ *\ j\  + \ 
                    Log[E, x]}]; \[IndentingNewLine]\(numdig[\ \ \ Mod[\ \ \
Floor[numat*1.0\ /\ 10^Floor[Log\ [10, \ numat]]\ ], \ 
                    10\ ]\ ]++\); \[IndentingNewLine]temp\  = \ 
                Exp[Log[10, \ numat]\  - \ 
                    j*Log[10, \ 
                        1.25]]; \[IndentingNewLine]\(lognumdig[\ \ \ Mod[\ \ \
Floor[temp*1.0\ /\ 10^Floor[Log\ [10, \ temp]]\ ], \ 
                    10\ ]\ ]++\); \[IndentingNewLine]numat\  = \ 
                5\ *\ numat + \ 1; \ \  (*\ 
                doing\ the\ 5  x + 
                  1\ problem\ *) \[IndentingNewLine]\ }\ \[IndentingNewLine]]\
\ \[IndentingNewLine]ListPlot[\ tempplot, \ 
            PlotJoined\  \[Rule] False]\ ; \[IndentingNewLine]Clear[
          tempplot]; \ 
        tempplot\  = \ {\ {0, 0}\ }; \[IndentingNewLine]For[\ m\  = \ 1, \ 
          m\  \[LessEqual] \ 9, \ \(m++\), \ 
          AppendTo[
            tempplot, \ {m, \ 
              1.0*numdig[m]\ /\ end}]]; \[IndentingNewLine]ListPlot[\ 
          tempplot]; \[IndentingNewLine]Clear[
          tempplot]; \[IndentingNewLine]\[IndentingNewLine]bF[y_]\  := \ 
          numdig[Floor[y\  + \  .5]]\ /\ end; \[IndentingNewLine]ben[
            y_]\  := \ Log[10, \ 
            1\  + \ \((1.0/y)\)]; \[IndentingNewLine]Plot[\ {bF[y], \ 
            ben[y]}, \ {y,  .5, 
            9.5}]; \[IndentingNewLine]\[IndentingNewLine]\ 
        tempplot\  = \ {\ {0, 0}\ }; \[IndentingNewLine]For[\ m\  = \ 1, \ 
          m\  \[LessEqual] \ 9, \ \(m++\), \ 
          AppendTo[
            tempplot, \ {m, \ 
              1.0*lognumdig[m]\ /\ end}]]; \[IndentingNewLine] (*\ \(ListPlot[
              tempplot];\)\ *) \[IndentingNewLine]\[IndentingNewLine]logbF[
            y_]\  := \ lognumdig[Floor[y\  + \  .5]]\ /\ 
            end; \[IndentingNewLine]Plot[\ {logbF[y], \ ben[y]}, \ {y,  .5, 
            9.5}];\[IndentingNewLine]\ ]\)], "Input"],

Cell[BoxData[
    \(glog[421, 1500]\)], "Input"]
},
FrontEndVersion->"5.0 for Microsoft Windows",
ScreenRectangle->{{0, 1280}, {0, 951}},
WindowSize->{1016, 685},
WindowMargins->{{0, Automatic}, {Automatic, 0}}
]

(*******************************************************************
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[1754, 51, 80, 1, 30, "Input"],
Cell[1837, 54, 265, 4, 50, "Input"],
Cell[2105, 60, 46, 1, 30, "Input"],
Cell[2154, 63, 47, 1, 30, "Input"],
Cell[2204, 66, 118, 2, 30, "Input"],
Cell[2325, 70, 54, 1, 30, "Input"],
Cell[2382, 73, 55, 1, 30, "Input"],
Cell[2440, 76, 392, 6, 70, "Input"],
Cell[2835, 84, 35, 1, 30, "Input"],
Cell[2873, 87, 38, 1, 30, "Input"],
Cell[2914, 90, 44, 1, 30, "Input"],
Cell[2961, 93, 68, 1, 30, "Input"],
Cell[3032, 96, 179, 3, 50, "Input"],
Cell[3214, 101, 43, 1, 30, "Input"],
Cell[3260, 104, 50, 1, 30, "Input"],
Cell[3313, 107, 245, 4, 70, "Input"],
Cell[3561, 113, 79, 1, 30, "Input"],
Cell[3643, 116, 47, 1, 30, "Input"],
Cell[3693, 119, 131, 2, 30, "Input"],
Cell[3827, 123, 255, 4, 50, "Input"],
Cell[4085, 129, 71, 1, 30, "Input"],
Cell[4159, 132, 69, 1, 30, "Input"],
Cell[4231, 135, 124, 3, 30, "Input"],
Cell[4358, 140, 223, 3, 50, "Input"],
Cell[4584, 145, 71, 1, 30, "Input"],
Cell[4658, 148, 123, 3, 30, "Input"],
Cell[4784, 153, 40, 1, 30, "Input"],
Cell[4827, 156, 142, 2, 30, "Input"],
Cell[4972, 160, 86, 1, 30, "Input"],
Cell[5061, 163, 41, 1, 30, "Input"],
Cell[5105, 166, 133, 2, 30, "Input"],
Cell[5241, 170, 76, 1, 30, "Input"],
Cell[5320, 173, 43, 1, 30, "Input"],
Cell[5366, 176, 92, 1, 30, "Input"],
Cell[5461, 179, 45, 1, 30, "Input"],
Cell[5509, 182, 54, 1, 30, "Input"],
Cell[5566, 185, 91, 2, 50, "Input"],
Cell[5660, 189, 198, 3, 50, "Input"],
Cell[5861, 194, 74, 1, 30, "Input"],
Cell[5938, 197, 59, 1, 30, "Input"],
Cell[6000, 200, 83, 1, 30, "Input"],
Cell[6086, 203, 123, 2, 30, "Input"],
Cell[6212, 207, 86, 1, 30, "Input"],
Cell[6301, 210, 43, 1, 30, "Input"],
Cell[6347, 213, 83, 1, 30, "Input"],
Cell[6433, 216, 109, 2, 30, "Input"],
Cell[6545, 220, 63, 1, 30, "Input"],
Cell[6611, 223, 133, 2, 30, "Input"],
Cell[6747, 227, 285, 6, 70, "Input"],
Cell[7035, 235, 58, 1, 30, "Input"],
Cell[7096, 238, 1111, 23, 210, "Input"],
Cell[8210, 263, 46, 1, 30, "Input"],
Cell[8259, 266, 113, 2, 30, "Input"],
Cell[8375, 270, 109, 2, 30, "Input"],
Cell[8487, 274, 37, 1, 30, "Input"],
Cell[8527, 277, 60, 1, 30, "Input"],
Cell[8590, 280, 46, 1, 30, "Input"],
Cell[8639, 283, 223, 5, 30, "Input"],
Cell[8865, 290, 378, 7, 70, "Input"],
Cell[9246, 299, 62, 1, 30, "Input"],
Cell[9311, 302, 26, 0, 30, "Input"],
Cell[9340, 304, 198, 4, 30, "Input"],
Cell[9541, 310, 190, 3, 30, "Input"],
Cell[9734, 315, 107, 2, 30, "Input"],
Cell[9844, 319, 131, 2, 110, "Input"],
Cell[9978, 323, 178, 3, 50, "Input"],
Cell[10159, 328, 99, 2, 30, "Input"],
Cell[10261, 332, 54, 1, 30, "Input"],
Cell[10318, 335, 133, 2, 50, "Input"],
Cell[10454, 339, 84, 1, 30, "Input"],
Cell[10541, 342, 464, 7, 90, "Input"],
Cell[11008, 351, 2826, 47, 470, "Input"],
Cell[13837, 400, 54, 1, 30, "Input"],
Cell[13894, 403, 225, 3, 190, "Input"],
Cell[14122, 408, 106, 2, 30, "Input"],
Cell[14231, 412, 174, 4, 30, "Input"],
Cell[14408, 418, 186, 3, 50, "Input"],
Cell[14597, 423, 105, 2, 30, "Input"],
Cell[14705, 427, 1413, 25, 370, "Input"],
Cell[16121, 454, 130, 3, 30, "Input"],
Cell[16254, 459, 164, 3, 50, "Input"],
Cell[16421, 464, 2986, 55, 670, "Input"],
Cell[19410, 521, 48, 1, 30, "Input"]
}
]
*)



(*******************************************************************
End of Mathematica Notebook file.
*******************************************************************)