Fix more copy and paste errors and typos.

# Quick Start Guide

graph_framework Graph computation framework that supports auto differentiation.

It is designed to allow domain scientists to create cross platform GPU 

accelerated code.

**graph_framework**: A graph computation framework that supports auto 

differentiation. It is designed to allow domain scientists to create cross 

platform GPU accelerated code and embed those codes in existing legacy tools.

## Documentation

[graph_framework-docs](https://ornl-fusion.github.io/graph_framework-docs) Documentation for the graph_framework.

[graph_framework-docs](https://ornl-fusion.github.io/graph_framework-docs) 

Documentation for the graph_framework.

## Obtaining the Code

To get started clone this repository using the command.

 * graph_framework into action. This will discuss building trees, generating

 * kernels, and executing workflows.

 *

 * To accomplish this there is a playground tool in the <tt>graph_framework</tt>

 * directory. This playground is a preconfigured executable target which can be

 * used to test out the API's of this framework. The playground starts with a

 * blank main function.

 * To accomplish this there is a playground tool in the

 * <tt>graph_playground</tt> directory. This playground is a preconfigured

 * executable target which can be used to test out the API's of this framework.

 * The playground starts with a blank main function.

 * @code

#include "../graph_framework/jit.hpp"

 @endcode

 * To start, create a template function above main and call that function from

 * main. This will allow us to play with different floating point types. For now

 * we will start with a simple floating point type.

 * we will start with a simple float type.

 * @code

#include "../graph_framework/jit.hpp"

 @endcode

 * Here @ref jit::float_scalar is a

 * <a href="https://www.cppreference.com/w/cpp/20.html">C++20</a>

 * <a href="https://www.cppreference.com/w/cpp/concepts.html">Concept</a> for

 * <a href="https://www.cppreference.com/w/cpp/concepts.html">Concept</a> of

 * valid floating point types allowed by the framework.

 *

 * <hr>

}

 @endcode

 * Here we are creating a @ref graph::variable_node with the symbol @f$x@f$

 * which holds 1000 elements. The symbol is used to by the @f$\LaTeX@f$ renderer

 * to use as a symbol place holder. Any graph can be rendered to latex by

 * which holds 1000 elements. The symbol is used by the @f$\LaTeX@f$ renderer

 * as a symbol place holder. Any graph can be rendered to @f$\LaTeX@f$ by

 * calling the @ref graph::leaf_node::to_latex method.

 * @code

template<jit::float_scalar T>

}

 @endcode

 * When compiling and running the code, this will print out the @f$\LaTeX@f$

 * code needed to generate the equation. By copy and pasting this into a

 * code needed to generate the equation. By copy and pasting this into

 * @f$\LaTeX@f$ it produces the symbol @f$x@f$. Note that all nodes of a graph

 * are wrapped in a

 * <a href="https://www.cppreference.com/w/cpp/memory/shared_ptr.html"><tt>std::shared_ptr</tt></a>.

    const T b = 0.6;

}

 @endcode

 * An explicit @ref graph::constant_node is create for <tt>m</tt> while an

 * An explicit @ref graph::constant_node is created for <tt>m</tt> while an

 * impicit constant was defined for <tt>b</tt>. Note in the implicit case, the

 * actual node for <tt>b</tt> is not created until we use it in an expression.

 *

auto dydy = y->df(y);

auto dydb = y->df(m*x);

 @endcode

 * The results will be @f$x@f$, @f$1@f$, and @f$0@f$ respectively.

 * The results will be @f$0.4@f$, @f$x@f$, @f$1@f$, and @f$0@f$ respectively.

 *

 * <hr>

 * @section tutorial_workflow Making workflows.

work.print(1, {x, y, dydx});

work.print(2, {x, y, dydx});

 @endcode

 * Restore the expected result.

 * This restores the expected result.

 * @code

1 1 0.4

2 1.4 0.4

 * <hr>

 * @section tutorial_workflow_newton Newton's Method.

 * In this tutorial we are going to show how we can put all these concepts

 * together to implement a newtons method. Newton's method is defined as

 * together to implement a Newton's method. Newton's method is defined as

 * @f{equation}{x = x - \frac{f\left(x\right)}{\frac{\partial}{\partial x}f\left(x\right)}@f}

 * From the iteration example, its step update can be handled by a simple map.

 * However we need a measure for convergence. To do that we output the value of

 * However, we need a measure for convergence. To do that we output the value of

 * @f$f\left(x\right)@f$. Lets setup a test function.

 * @code

template<jit::float_scalar T>

///  @endcode

///  Inital values for @f$k_{y}@f$ and @f$k_{z}@f$ will be sampled from a normal

///  distribution fuction. Both of them have a standard deviation of 10.

///  @f$k_{y}@f$ has a mean of 100 and @f$k_{z}@f$ has zero mean.

///  @f$k_{x}@f$ uses the default uniform value of 100. However, it

///  configured to solve for the a @f$k_{x}@f$ which satisfies the dispersion

///  function given the values of @f$\omega,k_{y},k_{z},\vec{x}@f$.

///  @f$k_{y}@f$ has a mean of -100 and @f$k_{z}@f$ has zero mean.

///  @f$k_{x}@f$ uses the default uniform value of -700.0. However, it is

///  configured to solve for @f$k_{x}@f$ which satisfies the dispersion function

///  given the values of @f$\omega,k_{y},k_{z},\vec{x}@f$.

///

///  @subsection xrays_commandline_example_model Ray Models.

///  @code

!>  @brief Implimentation of the Fortran binding library.

!-------------------------------------------------------------------------------

!>  @page graph_fortran_binding Embedding in Fortran code

!>  @brief Documentation for linking into Fortran code base.

!>  @brief Documentation for linking into a Fortran code base.

!>  @tableofcontents

!>

!>  @section graph_fortran_binding_into Introduction

!>  This section assumes the reader is already familar with developing Fortran

!>  codes. The simplist method is to create a C callable function like the

!>  @ref graph_c_binding_into "C binding exmaple". Then create a fortran

!>  @ref graph_c_binding_into "C binding exmaple". Then create a Fortran

!>  interface for it.

!>  @code

!>  INTERFACE

!>

!>  @note Graphs need to use the @ref graph_fortran::graph_ptr function to get

!>  the pointer address of node.

!>  @note The @ref graph_fortran::graph_null_array allows set arrays of nodes to

!>  null.

!>  @note The @ref graph_fortran::graph_null_array allows setting array of nodes

!>  arguments to null.

!-------------------------------------------------------------------------------

!> Module contains subroutines for calling this from fortran.

      MODULE graph_fortran

///

///  @section absorption_model_intro Introduction

///  This page documents the types of dispersion functions available. Tracing

///  the ray is only the first step in the process. Along that ray power is

///  the ray is only the first step in the process. Along that, ray power is

///  deposited into the plasma. For tracing the ray we assumed the wave number

///  was always real. However now we need to figure out what the imaginary

///  was always real. However, now we need to figure out what the imaginary

///  component is.

///

///  <hr>

///  @subsection absorption_model_hot Hot Plasma Disperison Function

///  To do this we know assume a hot plasma dispersion function.

///  To do this we now assume a hot plasma dispersion function.

///  @f{equation}{D\left(\vec{x},\vec{k},\omega\right)=i\sigma\Gamma_{0}+\Gamma_{1}+\vec{n}_{\perp}\cdot\vec{n}_{\perp}\frac{P\omega}{\omega_{ce}}\left(1+\zeta Z\left(\zeta\right)\right)\left(\Gamma_{2} + \Gamma_{5}F\right)\equiv 0 @f}

///  Where

///  @f{equation}{\Gamma_{0}=\vec{n}_{\perp}\cdot\vec{n}_{\perp}\left(\vec{n}\cdot\vec{n}-2\left(1-2q\right)\right)+\left(1-P\right)\left(2\left(1-2q\right)-\left(\vec{n}\cdot\vec{n}+n_{||}^{2}\right)\right)@f}