(************** 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[     21278,        620]*)
(*NotebookOutlinePosition[     21922,        642]*)
(*  CellTagsIndexPosition[     21878,        638]*)
(*WindowFrame->Normal*)



Notebook[{

Cell[CellGroupData[{
Cell["Haar Transform 1D", "Subtitle"],

Cell["\<\
Patrick J. Van Fleet
Minicourse #5, Joint Mathematics Meetings
New Orleans, LA\
\>", "Subsubtitle"],

Cell["Objective", "Section"],

Cell[CellGroupData[{

Cell["\<\
In this notebook, we will explore the one-dimensional discrete Haar wavelet \
transform.\
\>", "Subsubtitle"],

Cell["Conventions", "Section"]
}, Open  ]],

Cell[CellGroupData[{

Cell[TextData[{
  "This notebook uses the package ",
  StyleBox["WaveletFunctions",
    FontColor->RGBColor[0.501961, 0, 0]],
  " (written by Patrick Van Fleet).  All commands from the WaveletFunctions \
library will be denoted in ",
  StyleBox["maroon",
    FontColor->RGBColor[0.501961, 0, 0]],
  ".  Help is available for almost every command in ",
  StyleBox["WaveletFunctions",
    FontColor->RGBColor[0.501961, 0, 0]],
  ".  Click on Help and then Help Browser (or Shift F1).  Next click the \
Add-ons & Links tab.  Scroll down until you find ",
  StyleBox["WaveletFunctions",
    FontColor->RGBColor[0.501961, 0, 0]],
  ".  Like all ",
  StyleBox["Mathematica",
    FontSlant->"Italic"],
  " help screens, the help is \"live\" - you can either execute the commands \
in the help to see the effects of the command or cut and paste them into your \
own notebook.\n\nValues that can be changed by the user are defined using ",
  StyleBox["blue",
    FontColor->RGBColor[0, 0, 1]],
  ".\n\nComments are useful within cells of code.  Any code enclosed by (*  \
*) is a comment and ignored by the ",
  StyleBox["Mathematica",
    FontSlant->"Italic"],
  " kernel."
}], "Subsubtitle"],

Cell[CellGroupData[{

Cell["Load WaveletFunctions", "Section"],

Cell[BoxData[
    \(<< WaveletFunctions`WaveletFunctions`\)], "Input"]
}, Open  ]],

Cell["Spelling Off", "Section"]
}, Open  ]],

Cell[CellGroupData[{

Cell["\<\
This turns off the annoying error messages you get when the spelling of two \
variable names is close.\
\>", "Subsubtitle"],

Cell[BoxData[{
    \(\(Off[General::spell];\)\), "\[IndentingNewLine]", 
    \(\(Off[General::spell1];\)\)}], "Input"],

Cell["One-Dimensional Discrete Haar Transform Module", "Section"]
}, Open  ]],

Cell[CellGroupData[{

Cell["\<\
The cell below contains a module for computing the one-dimensional discrete \
Haar wavelet transform.  It takes as input a list of n elements.  The number \
of elements must be even or the module returns an error message.

The routine starts with an error check on the length of the input.  Then the \
input is partitioned into an n/2 x 2 matrix.  The matrix is multiplied by \
(1/2, 1/2) to obtain the top half of the transform and (-1/2,1/2) to form the \
bottom portion of the transform.  The two parts are joined together and \
returned by the module.
\
\>", "Subsubtitle"],

Cell[BoxData[
    \(\(HWT1D[x_] := 
        Module[{X, s, d, y}, \[IndentingNewLine]\t
          If[OddQ[Length[x]], 
            Return["\<The number of elements must be even.  No output \
returned.\>"]]; \[IndentingNewLine]\t
          X\  = \ Partition[x, 2, 2]; \[IndentingNewLine]\t
          s = X . {1/2, 1/2}; \[IndentingNewLine]\t
          d = X . {\(-1\)/2, 1/2}; \[IndentingNewLine]\t
          y = Join[s, d]; \[IndentingNewLine]\t
          Return[y];\[IndentingNewLine]];\)\)], "Input"],

Cell["Using HWT1D", "Section"]
}, Open  ]],

Cell[CellGroupData[{

Cell[TextData[{
  "The cells below contain commands that illustrate the use of ",
  StyleBox["HWT1D",
    FontWeight->"Bold"],
  ".  Feel free to change the input list x."
}], "Subsubtitle"],

Cell[BoxData[{
    StyleBox[\(x = {1, 2, 3, 4, 5, 6, 7, 8};\),
      FontColor->RGBColor[0, 0, 
      1]], "\[IndentingNewLine]", \(y = 
        HWT1D[x];\), "\[IndentingNewLine]", \(Print["\<The HWT of \>", 
        x, "\< is \>", y, "\<.\>"];\)}], "Input"]
}, Open  ]],

Cell[CellGroupData[{

Cell["What should HWT1D do to a constant vector?", "Subsubtitle"],

Cell[BoxData[{
    StyleBox[\(x = Table[1, {10}];\),
      FontColor->RGBColor[0, 0, 
      1]], "\[IndentingNewLine]", \(y = 
        HWT1D[x];\), "\[IndentingNewLine]", \(Print["\<The HWT of \>", 
        x, "\< is \>", y, "\<.\>"];\)}], "Input"]
}, Open  ]],

Cell[CellGroupData[{

Cell["\<\
Here is an example that introduces a command we can use to plot the wavelet \
transform.\
\>", "Subsubtitle"],

Cell[BoxData[{
    StyleBox[\(x = Table[k^2, {k, 1, 100}];\),
      FontColor->RGBColor[0, 0, 
      1]], "\[IndentingNewLine]", \(y = 
        HWT1D[x];\), "\[IndentingNewLine]", \(ListPlot[x, 
        PlotStyle \[Rule] Blue];\), "\[IndentingNewLine]", 
    RowBox[{
      StyleBox[\(WaveletVectorPlot[y, NumIterations \[Rule] 1, 
            Frame \[Rule] True, UseColors \[Rule] True];\),
        FontColor->RGBColor[0.501961, 0, 0]], "\[IndentingNewLine]", 
      "\[IndentingNewLine]", \( (*\ 
        Plot\ the\ differences\ only\ *) \)}], "\[IndentingNewLine]", 
    StyleBox[\(WaveletVectorPlot[y, NumIterations \[Rule] 1, 
          Frame \[Rule] True, UseColors \[Rule] True, 
          Region \[Rule] HighPass];\),
      FontColor->RGBColor[0.501961, 0, 0]]}], "Input"],

Cell["Partition, Flatten, Transpose", "Section"]
}, Open  ]],

Cell[CellGroupData[{

Cell[TextData[{
  "If you want to better understand the commands ",
  StyleBox["Partition,",
    FontWeight->"Bold"],
  " ",
  StyleBox["Flatten",
    FontWeight->"Bold"],
  ", and ",
  StyleBox["Transpose",
    FontWeight->"Bold"],
  ", have a look at the cells below.\n\nHere are two lists"
}], "Subsubtitle"],

Cell[BoxData[{
    \(a = {a1, a2, a3, a4}\), "\[IndentingNewLine]", 
    \(b = {b1, b2, b3, b4}\)}], "Input"]
}, Open  ]],

Cell[CellGroupData[{

Cell["\<\
We can build a 2 x 4 matrix from the lists.  The second command prints the \
output in a more conventional way.\
\>", "Subsubtitle"],

Cell[BoxData[{
    \({a, b}\), "\[IndentingNewLine]", 
    \(MatrixForm[{a, b}]\)}], "Input"]
}, Open  ]],

Cell[CellGroupData[{

Cell[TextData[{
  "We can perform operations like ",
  StyleBox["Transpose",
    FontWeight->"Bold"],
  "."
}], "Subsubtitle"],

Cell[BoxData[{
    \(Transpose[{a, b}]\), "\[IndentingNewLine]", 
    \(MatrixForm[Transpose[{a, b}]]\)}], "Input"],

Cell[BoxData[
    \(In\ the\ cell\ below, \ 
    we\ use\ Flatten\ and\ Transpose\ to\ intertwine\ the\ elements\ of\ a\ \
and\ b . \ \ Flatten\ simply\ removes\ all\ inner\ sets\ of\ {\ }\ \ leaving\ \
only\ a\ single\ list\ of\ \(\(numbers\)\(.\)\)\)], "Input"],

Cell[BoxData[{
    \(c = {a, b}\), "\[IndentingNewLine]", 
    \(MatrixForm[c]\), "\[IndentingNewLine]", 
    \(d = Transpose[c]\), "\[IndentingNewLine]", 
    \(MatrixForm[d]\), "\[IndentingNewLine]", 
    \(Flatten[d]\)}], "Input"],

Cell["One-Dimensional Inverse Discrete Haar Transform Module", "Section"]
}, Open  ]],

Cell[CellGroupData[{

Cell["\<\
The cell below contains a module for computing the one-dimensional inverse \
discrete Haar wavelet transform.  It takes as input a list of n elements.  \
The number of elements must be even or the module returns an error message.

The routine starts with an error check on the length of the input.  Then the \
input is partitioned into an 2 x n/2 matrix.  The matrix is multiplied by (1, \
-1) to obtain the odd elements of the transform and (1,1) to form the even \
elements of the transform.  The two parts are then intertwined and returned \
by the module.
\
\>", "Subsubtitle"],

Cell[BoxData[
    \(\(IHWT1D[y_] := 
        Module[{Y, a, b, x}, \[IndentingNewLine]\t
          If[OddQ[Length[y]], 
            Return["\<The number of elements must be even.  No output \
returned.\>"]]; \[IndentingNewLine]\t
          Y\  = \ Transpose[Partition[y, Length[y]/2]]; \[IndentingNewLine]\t
          a = \ Y . {1, \(-1\)}; \[IndentingNewLine]\t
          b = Y . {1, 1}; \[IndentingNewLine]\t
          x = Transpose[{a, b}]; \[IndentingNewLine]\t
          Return[Flatten[x]];\[IndentingNewLine]];\)\)], "Input"],

Cell["Using IHWT1D", "Section"]
}, Open  ]],

Cell[CellGroupData[{

Cell[TextData[{
  "The cell below contain illustrates the use of ",
  StyleBox["IHWT1D",
    FontWeight->"Bold"],
  ".   Feel free to change the input vector x.  For something different, I've \
formed x as a list of 20 random integers whose values range from 0 to 100."
}], "Subsubtitle"],

Cell[BoxData[{
    StyleBox[\(x = Table[Random[Integer, {0, 100}], {20}];\),
      FontColor->RGBColor[0, 0, 
      1]], "\[IndentingNewLine]", \(y = 
        HWT1D[x];\), "\[IndentingNewLine]", \(newx\  = \ 
        IHWT1D[y];\), "\[IndentingNewLine]", \(Print["\<The original input \
vector is \>", 
        x, "\<.\>"];\), "\[IndentingNewLine]", \(Print["\<The Haar transform \
of x is \>", 
        y, "\<.\>"];\), "\[IndentingNewLine]", \(Print["\<IHWT1D returns \>", 
        newx, "\<.\>"];\)}], "Input"],

Cell["An Illuminating Exercise for Students", "Section"]
}, Open  ]],

Cell[CellGroupData[{

Cell["\<\
I use this example every time I introduce the Haar wavelet transform.  The \
student can create a basic function from Calculus I (some examples are \
provided).  The function is then sampled 100 times from a to b.  This creates \
a list x that we plot.  Note the x-axis on the plot is in terms of the list \
elements while the y-axis is in terms of the list values.

Feel free to uncomment other functions, define your own, or change n, a, b.\
\>", "Subsubtitle"],

Cell[BoxData[{
    RowBox[{
      StyleBox[\(f[t_] := Sin[2*Pi*t];\),
        FontColor->RGBColor[0, 0, 1]], 
      StyleBox["\[IndentingNewLine]",
        FontColor->RGBColor[0, 0, 1]], 
      StyleBox[\( (*\ \(f[t_] := Cos[2*Pi*t];\)\ *) \),
        FontColor->RGBColor[0, 0, 1]], 
      StyleBox["\[IndentingNewLine]",
        FontColor->RGBColor[0, 0, 1]], 
      StyleBox[\( (*\ f[t_] := t^2\ *) \),
        FontColor->RGBColor[0, 0, 1]], 
      StyleBox["\[IndentingNewLine]",
        FontColor->RGBColor[0, 0, 1]], 
      StyleBox[\( (*\ f[t_] := t\ *) \),
        FontColor->RGBColor[0, 0, 1]], 
      StyleBox["\[IndentingNewLine]",
        FontColor->RGBColor[0, 0, 1]], 
      StyleBox[\( (*\ f[t_] := 1\ *) \),
        FontColor->RGBColor[0, 0, 1]], 
      StyleBox["\[IndentingNewLine]",
        FontColor->RGBColor[0, 0, 1]], 
      StyleBox[\( (*\ f[t_] := E^t\ *) \),
        FontColor->RGBColor[0, 0, 1]], 
      StyleBox["\[IndentingNewLine]",
        FontColor->RGBColor[0, 0, 1]], 
      StyleBox[\( (*\ \(f[t_] := Log[1 + t];\)\ *) \),
        FontColor->RGBColor[0, 0, 1]], 
      StyleBox["\[IndentingNewLine]",
        FontColor->RGBColor[0, 0, 1]]}], "\[IndentingNewLine]", 
    StyleBox[\(n = 100; \  (*\ 
        This\ must\ be\ \(even!\)\ *) \[IndentingNewLine]a = 0;\),
      FontColor->RGBColor[0, 0, 1]], "\[IndentingNewLine]", 
    RowBox[{
      StyleBox[\(b = 1;\),
        FontColor->RGBColor[0, 0, 1]], 
      "\[IndentingNewLine]"}], "\[IndentingNewLine]", \(x = 
        Table[f[a + k/n], {k, 0, 
            n - 1}];\), "\[IndentingNewLine]", \(ListPlot[x, 
        PlotStyle \[Rule] Red];\)}], "Input"]
}, Open  ]],

Cell[CellGroupData[{

Cell["\<\
Next compute the HWT of x.    The first plot is the entire transform.  The \
second plot shows only the approximation portion of the transform while the \
third plot shows only the differences portion of the transform.  

How are the second and third plots related?  Try a couple of other functions.\
\
\>", "Subsubtitle"],

Cell[BoxData[{
    RowBox[{\(y = HWT1D[x];\), "\[IndentingNewLine]"}], "\[IndentingNewLine]",
   
    StyleBox[\(WaveletVectorPlot[y, NumIterations \[Rule] 1, 
          Axes \[Rule] True, UseColors \[Rule] True, 
          DivideLines \[Rule] True];\),
      FontColor->RGBColor[0.501961, 0, 0]], "\[IndentingNewLine]", 
    StyleBox[\(WaveletVectorPlot[y, NumIterations \[Rule] 1, 
          Axes \[Rule] True, UseColors \[Rule] True, 
          DivideLines \[Rule] True, Region \[Rule] LowPass];\),
      FontColor->RGBColor[0.501961, 0, 0]], "\[IndentingNewLine]", 
    StyleBox[\(WaveletVectorPlot[y, NumIterations \[Rule] 1, 
          Axes \[Rule] True, UseColors \[Rule] True, 
          DivideLines \[Rule] True, Region \[Rule] HighPass];\),
      FontColor->RGBColor[0.501961, 0, 0]]}], "Input"],

Cell["Iterating the Process", "Section"]
}, Open  ]],

Cell[CellGroupData[{

Cell[TextData[{
  "In many applications, scientists will ",
  StyleBox["iterate",
    FontWeight->"Bold"],
  " the wavelet transform.  Suppose you are given n-vector x and you compute \
the HWT y.    The next iteration of transform is applied to the approximation \
portion of the y.  Here is some code (bulky) to do the job.  Note that to \
iterate a second time requires n to be divisible by 4.  "
}], "Subsubtitle"],

Cell[BoxData[{
    StyleBox[\(x\  = \ {2, 4, 6, 8, 10, 12, 14, 16};\),
      FontColor->RGBColor[0, 0, 
      1]], "\[IndentingNewLine]", \(n = 
        Length[x];\), "\[IndentingNewLine]", \(y = 
      HWT1D[x]\), "\[IndentingNewLine]", \(approx\  = \ 
      Take[y, n/2]\), "\[IndentingNewLine]", 
    RowBox[{\(diff\  = \ Drop[y, n/2]\), 
      "\[IndentingNewLine]"}], "\[IndentingNewLine]", \(z = 
      HWT1D[approx]\), "\[IndentingNewLine]", \(iterated\  = \ 
      Join[z, diff]\)}], "Input"]
}, Open  ]],

Cell[CellGroupData[{

Cell[TextData[{
  "In general, if the length of x contains the factor ",
  Cell[BoxData[
      \(2\^i\)]],
  ", we can iterate i times.  There is a routine in ",
  StyleBox["WaveletFunctions",
    FontColor->RGBColor[0.501961, 0, 0]],
  " for computing the iterated Haar Wavelet Transform.  It is called ",
  StyleBox["WT1D",
    FontWeight->"Bold"],
  ".  It needs three arguments.  The first is the input vector.  The second \
is the filter - i.e., the numbers used to obtain the approximation portion of \
the transform.  The input for the Haar transform is {1/2, 1/2}.  The routine \
figures out the numbers used for the difference portion of the transform.  \
The third input is the number of iterations.  \n\nHere is an example.  Note \
that the length of the input vector is divisible by 32 so we can perform as \
many as 5 iterations."
}], "Subsubtitle"],

Cell[BoxData[{
    StyleBox[\(n = 96;\),
      FontColor->RGBColor[0, 0, 1]], "\[IndentingNewLine]", 
    StyleBox[\(x = Table[\((k/n)\)^2, {k, 0, n - 1}];\),
      FontColor->RGBColor[0, 0, 1]], "\n", 
    RowBox[{
      RowBox[{
        RowBox[{"y", "=", 
          StyleBox[\(WT1D[x, { .5,  .5}, NumIterations \[Rule] 2]\),
            FontColor->RGBColor[0.501961, 0, 0]]}], 
        StyleBox[";",
          FontColor->RGBColor[0.501961, 0, 0]]}], 
      "\[IndentingNewLine]"}], "\[IndentingNewLine]", 
    StyleBox[\(WaveletVectorPlot[y, NumIterations \[Rule] 2, 
          Frame \[Rule] True, DivideLines \[Rule] True, 
          DivideLinesColor \[Rule] LightGray, UseColors \[Rule] True, 
          PlotRange \[Rule] All];\),
      FontColor->RGBColor[0.501961, 0, 0]]}], "Input"]
}, Open  ]],

Cell[CellGroupData[{

Cell[TextData[{
  "Here is three iterations of the transform.  Note the approximation portion \
contains 96/",
  Cell[BoxData[
      \(2\^3\)]],
  " = 12 elements."
}], "Subsubtitle"],

Cell[BoxData[{
    RowBox[{
      RowBox[{
        RowBox[{"y", "=", 
          StyleBox[\(WT1D[x, { .5,  .5}, NumIterations \[Rule] 3]\),
            FontColor->RGBColor[0.501961, 0, 0]]}], 
        StyleBox[";",
          FontColor->RGBColor[0.501961, 0, 0]]}], 
      "\[IndentingNewLine]"}], "\[IndentingNewLine]", 
    StyleBox[\(WaveletVectorPlot[y, NumIterations \[Rule] 3, 
          Frame \[Rule] True, DivideLines \[Rule] True, 
          DivideLinesColor \[Rule] LightGray, UseColors \[Rule] True, 
          PlotRange \[Rule] All];\),
      FontColor->RGBColor[0.501961, 0, 0]]}], "Input"]
}, Open  ]],

Cell[CellGroupData[{

Cell["You can look at particular portions of the transform.", "Subsubtitle"],

Cell[BoxData[{
    RowBox[{
      StyleBox[\(WaveletVectorPlot[y, NumIterations \[Rule] 3, 
            Frame \[Rule] True, DivideLines \[Rule] True, 
            DivideLinesColor \[Rule] LightGray, UseColors \[Rule] True, 
            PlotRange \[Rule] All, Iteration \[Rule] 2, 
            Region \[Rule] HighPass];\),
        FontColor->RGBColor[0.501961, 0, 0]], 
      "\[IndentingNewLine]"}], "\[IndentingNewLine]", 
    StyleBox[\(WaveletVectorPlot[y, NumIterations \[Rule] 3, 
          Frame \[Rule] True, DivideLines \[Rule] True, 
          DivideLinesColor \[Rule] LightGray, UseColors \[Rule] True, 
          PlotRange \[Rule] All, Region \[Rule] LowPass];\),
      FontColor->RGBColor[0.501961, 0, 0]]}], "Input"]
}, Open  ]],

Cell[CellGroupData[{

Cell[TextData[{
  "The process is invertible using the ",
  StyleBox["IWT1D",
    FontWeight->"Bold"],
  " routine from ",
  StyleBox["WaveletFunctions",
    FontColor->RGBColor[0.501961, 0, 0]],
  ".  Like ",
  StyleBox["WT1D",
    FontWeight->"Bold"],
  ", the routine requires three arguments.  The first is the input vector, \
the second is the list of numbers used for the left half of ",
  Cell[BoxData[
      \(W\_N\%\(-1\)\)]],
  " (in this case {1, 1}), and the third argument is the number of \
iterations."
}], "Subsubtitle"],

Cell[BoxData[{
    StyleBox[\(x\  = \ Table[Random[Integer, {0, 100}], {32}];\),
      FontColor->RGBColor[0, 0, 1]], "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{"y", "=", 
        StyleBox[\(WT1D[x, {1/2, 1/2}, NumIterations \[Rule] 5]\),
          FontColor->RGBColor[0.501961, 0, 0]]}], 
      StyleBox[";",
        FontColor->RGBColor[0.501961, 0, 0]]}], "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{
        RowBox[{"orig", " ", "=", " ", 
          StyleBox[\(IWT1D[y, {1, 1}, NumIterations \[Rule] 5]\),
            FontColor->RGBColor[0.501961, 0, 0]]}], 
        StyleBox[";",
          FontColor->RGBColor[0.501961, 0, 0]]}], 
      "\[IndentingNewLine]"}], "\[IndentingNewLine]", \(Print["\<The original \
input vector is \>", 
        x, "\<.\>"];\), "\[IndentingNewLine]", \(Print["\<The Haar transform \
of x is \>", 
        y, "\<.\>"];\), "\[IndentingNewLine]", \(Print["\<IWT1D returns \>", 
        orig, "\<.\>"];\)}], "Input"],

Cell["Orthogonalizing the Transform", "Section"]
}, Open  ]],

Cell[CellGroupData[{

Cell["\<\
In the early development of wavelets, the transforms were designed to be \
orthogonal matrices.  Consider the Haar Wavelet transform matrix of size 8 x \
8 and its inverse:\
\>", "Subsubtitle"],

Cell[BoxData[{
    \(\(h = Join[{1/2, 1/2}, Table[0, {6}]];\)\), "\[IndentingNewLine]", 
    \(\(tp = 
        Table[RotateRight[h, 2*k], {k, 0, 3}];\)\), "\[IndentingNewLine]", 
    \(\(g = 
        Join[{\(-1\)/2, 1/2}, Table[0, {6}]];\)\), "\[IndentingNewLine]", 
    \(\(bt = 
        Table[RotateRight[g, 2*k], {k, 0, 3}];\)\), "\[IndentingNewLine]", 
    \(\(W8\  = \ Join[tp, bt];\)\), "\[IndentingNewLine]", 
    \(MatrixForm[W8]\), "\[IndentingNewLine]", 
    \(MatrixForm[Inverse[W8]]\), "\[IndentingNewLine]", 
    \(\)}], "Input"]
}, Open  ]],

Cell[CellGroupData[{

Cell[TextData[{
  "How could we modify the matrix so that it is orthgonal?\n\n",
  "\n",
  "When we use orthogonal transformations, we can use the same list as the \
second arguments for ",
  StyleBox["WT1D",
    FontColor->RGBColor[0.501961, 0, 0]],
  " and ",
  StyleBox["IWT1D",
    FontColor->RGBColor[0.501961, 0, 0]],
  ".  There is a command in ",
  StyleBox["WaveletFunctions",
    FontColor->RGBColor[0.501961, 0, 0]],
  " for generating this list:"
}], "Subsubtitle"],

Cell[BoxData[
    StyleBox[\(Haar[]\),
      FontColor->RGBColor[0.501961, 0, 0]]], "Input"]
}, Open  ]]
}, Open  ]]
},
FrontEndVersion->"5.2 for Microsoft Windows",
ScreenRectangle->{{0, 1024}, {0, 685}},
WindowSize->{1016, 651},
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[CellGroupData[{
Cell[1776, 53, 37, 0, 51, "Subtitle"],
Cell[1816, 55, 109, 4, 70, "Subsubtitle"],
Cell[1928, 61, 28, 0, 73, "Section"],

Cell[CellGroupData[{
Cell[1981, 65, 119, 3, 30, "Subsubtitle"],
Cell[2103, 70, 30, 0, 73, "Section"]
}, Open  ]],

Cell[CellGroupData[{
Cell[2170, 75, 1184, 28, 172, "Subsubtitle"],

Cell[CellGroupData[{
Cell[3379, 107, 40, 0, 73, "Section"],
Cell[3422, 109, 70, 1, 30, "Input"]
}, Open  ]],
Cell[3507, 113, 31, 0, 73, "Section"]
}, Open  ]],

Cell[CellGroupData[{
Cell[3575, 118, 133, 3, 30, "Subsubtitle"],
Cell[3711, 123, 118, 2, 50, "Input"],
Cell[3832, 127, 65, 0, 73, "Section"]
}, Open  ]],

Cell[CellGroupData[{
Cell[3934, 132, 587, 11, 150, "Subsubtitle"],
Cell[4524, 145, 501, 10, 170, "Input"],
Cell[5028, 157, 30, 0, 73, "Section"]
}, Open  ]],

Cell[CellGroupData[{
Cell[5095, 162, 190, 5, 31, "Subsubtitle"],
Cell[5288, 169, 258, 5, 70, "Input"]
}, Open  ]],

Cell[CellGroupData[{
Cell[5583, 179, 65, 0, 30, "Subsubtitle"],
Cell[5651, 181, 248, 5, 70, "Input"]
}, Open  ]],

Cell[CellGroupData[{
Cell[5936, 191, 119, 3, 30, "Subsubtitle"],
Cell[6058, 196, 780, 15, 150, "Input"],
Cell[6841, 213, 48, 0, 73, "Section"]
}, Open  ]],

Cell[CellGroupData[{
Cell[6926, 218, 311, 11, 71, "Subsubtitle"],
Cell[7240, 231, 109, 2, 50, "Input"]
}, Open  ]],

Cell[CellGroupData[{
Cell[7386, 238, 142, 3, 30, "Subsubtitle"],
Cell[7531, 243, 93, 2, 50, "Input"]
}, Open  ]],

Cell[CellGroupData[{
Cell[7661, 250, 126, 5, 31, "Subsubtitle"],
Cell[7790, 257, 115, 2, 50, "Input"],
Cell[7908, 261, 263, 4, 50, "Input"],
Cell[8174, 267, 233, 5, 110, "Input"],
Cell[8410, 274, 73, 0, 73, "Section"]
}, Open  ]],

Cell[CellGroupData[{
Cell[8520, 279, 591, 11, 150, "Subsubtitle"],
Cell[9114, 292, 530, 10, 170, "Input"],
Cell[9647, 304, 31, 0, 73, "Section"]
}, Open  ]],

Cell[CellGroupData[{
Cell[9715, 309, 288, 6, 51, "Subsubtitle"],
Cell[10006, 317, 511, 10, 130, "Input"],
Cell[10520, 329, 56, 0, 73, "Section"]
}, Open  ]],

Cell[CellGroupData[{
Cell[10613, 334, 473, 8, 110, "Subsubtitle"],
Cell[11089, 344, 1642, 39, 290, "Input"]
}, Open  ]],

Cell[CellGroupData[{
Cell[12768, 388, 332, 7, 90, "Subsubtitle"],
Cell[13103, 397, 805, 14, 110, "Input"],
Cell[13911, 413, 40, 0, 73, "Section"]
}, Open  ]],

Cell[CellGroupData[{
Cell[13988, 418, 418, 8, 71, "Subsubtitle"],
Cell[14409, 428, 500, 10, 170, "Input"]
}, Open  ]],

Cell[CellGroupData[{
Cell[14946, 443, 862, 17, 131, "Subsubtitle"],
Cell[15811, 462, 789, 17, 130, "Input"]
}, Open  ]],

Cell[CellGroupData[{
Cell[16637, 484, 183, 6, 30, "Subsubtitle"],
Cell[16823, 492, 601, 13, 90, "Input"]
}, Open  ]],

Cell[CellGroupData[{
Cell[17461, 510, 76, 0, 30, "Subsubtitle"],
Cell[17540, 512, 729, 13, 110, "Input"]
}, Open  ]],

Cell[CellGroupData[{
Cell[18306, 530, 536, 16, 71, "Subsubtitle"],
Cell[18845, 548, 960, 21, 150, "Input"],
Cell[19808, 571, 48, 0, 73, "Section"]
}, Open  ]],

Cell[CellGroupData[{
Cell[19893, 576, 203, 4, 50, "Subsubtitle"],
Cell[20099, 582, 542, 11, 170, "Input"]
}, Open  ]],

Cell[CellGroupData[{
Cell[20678, 598, 477, 14, 110, "Subsubtitle"],
Cell[21158, 614, 92, 2, 30, "Input"]
}, Open  ]]
}, Open  ]]
}
]
*)



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