From e53c35223bed9a32f1e9cd3fe75caf344d4b5c7e Mon Sep 17 00:00:00 2001
From: Christian Kolset <christian.kolset@gmail.com>
Date: Thu, 24 Apr 2025 17:37:21 -0600
Subject: Updated tex files

---
 book/module1/array.tex | 293 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 293 insertions(+)
 create mode 100644 book/module1/array.tex

(limited to 'book/module1/array.tex')

diff --git a/book/module1/array.tex b/book/module1/array.tex
new file mode 100644
index 0000000..db176e7
--- /dev/null
+++ b/book/module1/array.tex
@@ -0,0 +1,293 @@
+\section{Arrays}\label{arrays}
+
+In computer programming, an array is a structure for storing and
+retrieving data. We often talk about an array as if it were a grid in
+space, with each cell storing one element of the data. For instance, if
+each element of the data were a number, we might visualize a
+``one-dimensional'' array like a list:
+
+\begin{longtable}[]{@{}llll@{}}
+\toprule\noalign{}
+1 & 5 & 2 & 0 \\
+\midrule\noalign{}
+\endhead
+\bottomrule\noalign{}
+\endlastfoot
+\end{longtable}
+
+A two-dimensional array would be like a table:
+
+\begin{longtable}[]{@{}llll@{}}
+\toprule\noalign{}
+1 & 5 & 2 & 0 \\
+\midrule\noalign{}
+\endhead
+\bottomrule\noalign{}
+\endlastfoot
+8 & 3 & 6 & 1 \\
+1 & 7 & 2 & 9 \\
+\end{longtable}
+
+A three-dimensional array would be like a set of tables, perhaps stacked
+as though they were printed on separate pages. If we visualize the
+position of each element as a position in space. Then we can represent
+the value of the element as a property. In other words, if we were to
+analyze the stress concentration of an aluminum block, the property
+would be stress.
+
+\begin{itemize}
+\tightlist
+\item
+  From
+  \href{https://numpy.org/doc/2.2/user/absolute_beginners.html}{Numpy
+  documentation}
+  \includegraphics{https://www.mathworks.com/help/examples/matlab/win64/nddemo_02.gif}
+\end{itemize}
+
+If the load on this block changes over time, then we may want to add a
+4th dimension i.e.~additional sets of 3-D arrays for each time
+increment. As you can see - the more dimensions we add, the more
+complicated of a problem we have to solve. It is possible to increase
+the number of dimensions to the n-th order. This course we will not be
+going beyond dimensional analysis.
+
+\subsection{Numpy - the python's array
+library}\label{numpy---the-pythons-array-library}
+
+In this tutorial we will be introducing arrays and we will be using the
+numpy library. Arrays, lists, vectors, matrices, sets - You might've
+heard of them before, they all store data. In programming, an array is a
+variable that can hold more than one value at a time. We will be using
+the Numpy python library to create arrays. Since we already have
+installed Numpy previously, we can start using the package.
+
+Before importing our first package, let's as ourselves \emph{what is a
+package?} A package can be thought of as pre-written python code that we
+can re-use. This means the for every script that we write in python we
+need to tell it to use a certain package. We call this importing a
+package.
+
+\subsubsection{Importing Numpy}\label{importing-numpy}
+
+When using packages in python, we need to let it know what package we
+will be using. This is called importing. To import numpy we need to
+declare it a the start of a script as follows:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ImportTok{import}\NormalTok{ numpy }\ImportTok{as}\NormalTok{ np}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{itemize}
+\tightlist
+\item
+  \texttt{import} - calls for a library to use, in our case it is Numpy.
+\item
+  \texttt{as} - gives the library an alias in your script. It's common
+  convention in Python programming to make the code shorter and more
+  readable. We will be using \emph{np} as it's a standard using in many
+  projects.
+\end{itemize}
+
+\subsection{Creating arrays}\label{creating-arrays}
+
+Now that we have imported the library we can create a one dimensional
+array or \emph{vector} with three elements.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{x }\OperatorTok{=}\NormalTok{ np.array([}\DecValTok{1}\NormalTok{,}\DecValTok{2}\NormalTok{,}\DecValTok{3}\NormalTok{])}
+\end{Highlighting}
+\end{Shaded}
+
+To create a \emph{matrix} we can nest the arrays to create a two
+dimensional array. This is done as follows.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{matrix }\OperatorTok{=}\NormalTok{ np.array([[}\DecValTok{1}\NormalTok{,}\DecValTok{2}\NormalTok{,}\DecValTok{3}\NormalTok{],}
+\NormalTok{                   [}\DecValTok{4}\NormalTok{,}\DecValTok{5}\NormalTok{,}\DecValTok{6}\NormalTok{],}
+\NormalTok{                   [}\DecValTok{7}\NormalTok{,}\DecValTok{8}\NormalTok{,}\DecValTok{9}\NormalTok{]])}
+\end{Highlighting}
+\end{Shaded}
+
+\emph{Note: for every array we nest, we get a new dimension in our data
+structure.}
+
+\subsubsection{Numpy array creation
+functions}\label{numpy-array-creation-functions}
+
+Numpy comes with some built-in function that we can use to create arrays
+quickly. Here are a couple of functions that are commonly used in
+python. \#\#\#\# np.arange The \texttt{np.arange()} function returns an
+array with evenly spaced values within a specified range. It is similar
+to the built-in \texttt{range()} function in Python but returns a Numpy
+array instead of a list. The parameters for this function are the start
+value (inclusive), the stop value (exclusive), and the step size. If the
+step size is not provided, it defaults to 1.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\OperatorTok{\textgreater{}\textgreater{}\textgreater{}}\NormalTok{ np.arange(}\DecValTok{4}\NormalTok{)}
+\NormalTok{array([}\FloatTok{0.}\NormalTok{ , }\FloatTok{1.}\NormalTok{, }\FloatTok{2.}\NormalTok{, }\FloatTok{3.}\NormalTok{ ])}
+\end{Highlighting}
+\end{Shaded}
+
+In this example, \texttt{np.arange(4)} generates an array starting from
+0 and ending before 4, with a step size of 1.
+
+\paragraph{np.linspace}\label{np.linspace}
+
+The \texttt{np.linspace()} function returns an array of evenly spaced
+values over a specified range. Unlike \texttt{np.arange()}, which uses a
+step size to define the spacing between elements, \texttt{np.linspace()}
+uses the number of values you want to generate and calculates the
+spacing automatically. It accepts three parameters: the start value, the
+stop value, and the number of samples.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\OperatorTok{\textgreater{}\textgreater{}\textgreater{}}\NormalTok{ np.linspace(}\FloatTok{1.}\NormalTok{, }\FloatTok{4.}\NormalTok{, }\DecValTok{6}\NormalTok{)}
+\NormalTok{array([}\FloatTok{1.}\NormalTok{ ,  }\FloatTok{1.6}\NormalTok{,  }\FloatTok{2.2}\NormalTok{,  }\FloatTok{2.8}\NormalTok{,  }\FloatTok{3.4}\NormalTok{,  }\FloatTok{4.}\NormalTok{ ])}
+\end{Highlighting}
+\end{Shaded}
+
+In this example, \texttt{np.linspace(1.,\ 4.,\ 6)} generates 6 evenly
+spaced values between 1. and 4., including both endpoints.
+
+Try this and see what happens:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{x }\OperatorTok{=}\NormalTok{ np.linspace(}\DecValTok{0}\NormalTok{,}\DecValTok{100}\NormalTok{,}\DecValTok{101}\NormalTok{)}
+\NormalTok{y }\OperatorTok{=}\NormalTok{ np.sin(x)}
+\end{Highlighting}
+\end{Shaded}
+
+\paragraph{Other useful functions}\label{other-useful-functions}
+
+\begin{itemize}
+\tightlist
+\item
+  \texttt{np.zeros()}
+\item
+  \texttt{np.ones()}
+\item
+  \texttt{np.eye()}
+\end{itemize}
+
+\subsubsection{Working with Arrays}\label{working-with-arrays}
+
+Now that we have been introduced to some ways to create arrays using the
+Numpy functions let's start using them. \#\#\#\# Indexing Indexing in
+Python allows you to access specific elements within an array based on
+their position. This means you can directly retrieve and manipulate
+individual items as needed.
+
+Python uses \textbf{zero-based indexing}, meaning the first element is
+at position \textbf{0} rather than \textbf{1}. This approach is common
+in many programming languages. For example, in a list with five
+elements, the first element is at index \texttt{0}, followed by elements
+at indices \texttt{1}, \texttt{2}, \texttt{3}, and \texttt{4}.
+
+Here's an example of data from a rocket test stand where thrust was
+recorded as a function of time.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{thrust\_lbf }\OperatorTok{=}\NormalTok{ np.array(}\FloatTok{0.603355}\NormalTok{, }\FloatTok{2.019083}\NormalTok{, }\FloatTok{2.808092}\NormalTok{, }\FloatTok{4.054973}\NormalTok{, }\FloatTok{1.136618}\NormalTok{, }\FloatTok{0.943668}\NormalTok{)}
+
+\OperatorTok{\textgreater{}\textgreater{}\textgreater{}}\NormalTok{ thrust\_lbs[}\DecValTok{3}\NormalTok{]}
+\end{Highlighting}
+\end{Shaded}
+
+Due to the nature of zero-based indexing. If we want to call the value
+\texttt{4.054973} that will be the 3rd index. \#\#\#\# Operations on
+arrays - Arithmetic operations (\texttt{+}, \texttt{-}, \texttt{*},
+\texttt{/}, \texttt{**}) - \texttt{np.add()}, \texttt{np.subtract()},
+\texttt{np.multiply()}, \texttt{np.divide()} - \texttt{np.dot()} for dot
+product - \texttt{np.matmul()} for matrix multiplication -
+\texttt{np.linalg.inv()}, \texttt{np.linalg.det()} for linear algebra
+\#\#\#\#\# Statistics - \texttt{np.mean()}, \texttt{np.median()},
+\texttt{np.std()}, \texttt{np.var()} - \texttt{np.min()},
+\texttt{np.max()}, \texttt{np.argmin()}, \texttt{np.argmax()} -
+Summation along axes: \texttt{np.sum(arr,\ axis=0)} \#\#\#\#\# Combining
+arrays - Concatenation: \texttt{np.concatenate((arr1,\ arr2),\ axis=0)}
+- Stacking: \texttt{np.vstack()}, \texttt{np.hstack()} - Splitting:
+\texttt{np.split()}
+
+\subsection{Exercise}\label{exercise}
+
+Let's solve a statics problem given the following problem
+
+A simply supported bridge of length L=20L = 20L=20 m is subjected to
+three point loads:
+
+\begin{itemize}
+\tightlist
+\item
+  \(P1=10P_1 = 10P1​=10 kN\) at \(x=5x = 5x=5 m\)
+\item
+  \(P2=15P_2 = 15P2​=15 kN\) at \(x=10x = 10x=10 m\)
+\item
+  \(P3=20P_3 = 20P3​=20 kN\) at \(x=15x = 15x=15 m\)
+\end{itemize}
+
+The bridge is supported by two reaction forces at points AAA (left
+support) and BBB (right support). We assume the bridge is in static
+equilibrium, meaning the sum of forces and sum of moments about any
+point must be zero.
+
+\subparagraph{Equilibrium Equations:}\label{equilibrium-equations}
+
+\begin{enumerate}
+\def\labelenumi{\arabic{enumi}.}
+\tightlist
+\item
+  \textbf{Sum of Forces in the Vertical Direction}:
+  \(RA+RB−P1−P2−P3=0R_A + R_B - P_1 - P_2 - P_3 = 0RA​+RB​−P1​−P2​−P3​=0\)
+\item
+  \textbf{Sum of Moments About Point A}:
+  \(5P1+10P2+15P3−20RB=05 P_1 + 10 P_2 + 15 P_3 - 20 R_B = 05P1​+10P2​+15P3​−20RB​=0\)
+\item
+  \textbf{Sum of Moments About Point B}:
+  \(20RA−15P3−10P2−5P1=020 R_A - 15 P_3 - 10 P_2 - 5 P_1 = 020RA​−15P3​−10P2​−5P1​=0\)
+\end{enumerate}
+
+\subparagraph{System of Equations:}\label{system-of-equations}
+
+\{RA+RB−10−15−20=05(10)+10(15)+15(20)−20RB=020RA−5(10)−10(15)−15(20)=0
+
+\begin{cases} R_A + R_B - 10 - 15 - 20 = 0 \\ 5(10) + 10(15) + 15(20) - 20 R_B = 0 \\ 20 R_A - 5(10) - 10(15) - 15(20) = 0 \end{cases}
+
+⎩
+
+\subsubsection{Solution}\label{solution}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ImportTok{import}\NormalTok{ numpy }\ImportTok{as}\NormalTok{ np}
+
+\CommentTok{\# Define the coefficient matrix A}
+\NormalTok{A }\OperatorTok{=}\NormalTok{ np.array([}
+\NormalTok{    [}\DecValTok{1}\NormalTok{, }\DecValTok{1}\NormalTok{],}
+\NormalTok{    [}\DecValTok{0}\NormalTok{, }\OperatorTok{{-}}\DecValTok{20}\NormalTok{],}
+\NormalTok{    [}\DecValTok{20}\NormalTok{, }\DecValTok{0}\NormalTok{]}
+\NormalTok{])}
+
+\CommentTok{\# Define the right{-}hand side vector b}
+\NormalTok{b }\OperatorTok{=}\NormalTok{ np.array([}
+    \DecValTok{45}\NormalTok{,}
+    \DecValTok{5}\OperatorTok{*}\DecValTok{10} \OperatorTok{+} \DecValTok{10}\OperatorTok{*}\DecValTok{15} \OperatorTok{+} \DecValTok{15}\OperatorTok{*}\DecValTok{20}\NormalTok{,}
+    \DecValTok{5}\OperatorTok{*}\DecValTok{10} \OperatorTok{+} \DecValTok{10}\OperatorTok{*}\DecValTok{15} \OperatorTok{+} \DecValTok{15}\OperatorTok{*}\DecValTok{20}
+\NormalTok{])}
+
+\CommentTok{\# Solve the system of equations Ax = b}
+\NormalTok{x }\OperatorTok{=}\NormalTok{ np.linalg.lstsq(A, b, rcond}\OperatorTok{=}\VariableTok{None}\NormalTok{)[}\DecValTok{0}\NormalTok{]  }\CommentTok{\# Using least squares to handle potential overdetermination}
+
+\CommentTok{\# Display the results}
+\BuiltInTok{print}\NormalTok{(}\SpecialStringTok{f"Reaction force at A (R\_A): }\SpecialCharTok{\{}\NormalTok{x[}\DecValTok{0}\NormalTok{]}\SpecialCharTok{:.2f\}}\SpecialStringTok{ kN"}\NormalTok{)}
+\BuiltInTok{print}\NormalTok{(}\SpecialStringTok{f"Reaction force at B (R\_B): }\SpecialCharTok{\{}\NormalTok{x[}\DecValTok{1}\NormalTok{]}\SpecialCharTok{:.2f\}}\SpecialStringTok{ kN"}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
-- 
cgit v1.2.3

