4_numericaldata.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Pkg\n",
    "\n",
    "Pkg.activate(\".\") # change path if you haven't launched notebook from base of repo\n",
    "Pkg.instantiate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear Algebra\n",
    "Here we'll demonstrate some basic linear algebraic functionality using the Base (i.e. built into Julia and doesn't need to be installed, only imported) [LinearAlgebra](https://docs.julialang.org/en/v1/stdlib/LinearAlgebra/) package."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "using LinearAlgebra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's initialize a nice matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = [1 2 3; 4 5 6; 7 8 9]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What's its determinant? (Oops, maybe it's not so nice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "det(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay, let's make a new matrix and take the inverse:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = [2 1 1; 1 2 1; 1 1 2]\n",
    "inv(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How about eigendecomposition?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eig_B = eigen(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default an `Eigen` object is returned, which we can pull out the fields of as `eig_B.values` or `eig_B.vectors`, but we can also pre-assign them like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vals, vecs = eigen(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the eigenvectors are the columns..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vecs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have a backslash like in MATLAB, too..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE**: the backslash operator divides the argument on its right by the one on its left, commonly used to solve matrix equations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = [1, 2, 3]\n",
    "x = A \\ b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More things!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will solve the following system of equations:\n",
    "\n",
    "```math\n",
    "x_1 + 2x_2 - x_3 + x_4 = 1 \\\\\n",
    "2x_1 - x_2 + 3x_3 - 2x_4 = 5 \\\\\n",
    "-3x_1 + 4x_2 + 2x_3 + x_4 = 7 \\\\\n",
    "x_1 - 3x_2 + 2x_3 - 4x_4 = -2 \\\\\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can be written in matrix form `Ax = b` as:\n",
    "\n",
    "```math\n",
    "A =\n",
    "\\begin{bmatrix}\n",
    "1 & 2 & -1 & 1 \\\\\n",
    "2 & -1 & 3 & -2 \\\\\n",
    "-3 & 4 & 2 & 1 \\\\\n",
    "1 & -3 & 2 & -4 \\\\\n",
    "\\end{bmatrix}\n",
    "x =\n",
    "\\begin{bmatrix}\n",
    "x_1 \\\\\n",
    "x_2 \\\\\n",
    "x_3 \\\\\n",
    "x_4 \\\\\n",
    "\\end{bmatrix}\n",
    "b =\n",
    "\\begin{bmatrix}\n",
    "1 \\\\\n",
    "5 \\\\\n",
    "7 \\\\\n",
    "-2 \\\\\n",
    "\\end{bmatrix}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define matrix A and vector b\n",
    "A = [1 2 -1 1; 2 -1 3 -2; -3 4 2 1; 1 -3 2 -4]\n",
    "b = [1, 5, 7, -2]\n",
    "\n",
    "# Solve for x using the backslash operator\n",
    "x = A \\ b\n",
    "\n",
    "# Compute the rank of A\n",
    "rank_A = rank(A)\n",
    "\n",
    "# Compute the null space of A\n",
    "null_space_A = nullspace(A)\n",
    "\n",
    "# Compute the condition number of A\n",
    "cond_A = cond(A)\n",
    "\n",
    "# Display results\n",
    "println(\"Solution x: \", x)\n",
    "println(\"Rank of A: \", rank_A)\n",
    "println(\"Null space of A: \", null_space_A)\n",
    "println(\"Condition number of A: \", cond_A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Special Matrices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Julia provides for a bunch of special matrix types on which standard operations are further optimized; you can read more about them [here](https://docs.julialang.org/en/v1/stdlib/LinearAlgebra/#Special-matrices). We explore a few examples below.\n",
    "\n",
    "**Symmetric Matrices**: Julia provides the `Symmetric` type for creating symmetric matrices, where the matrix is equal to its transpose. This saves storage space by storing only the upper triangular part of the matrix. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a symmetric matrix\n",
    "A = [1 2 3; 2 4 5; 3 5 6]\n",
    "S = Symmetric(A)\n",
    "\n",
    "println(S)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Sparse Matrices**: Sparse matrices are useful when you have a large matrix with mostly zero elements. Julia provides efficient storage and operations for sparse matrices via the `SparseArrays` package."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "using SparseArrays\n",
    "\n",
    "# Create a sparse matrix\n",
    "I = sparse([1, 3, 4], [2, 1, 3], [10, 20, 30], 5, 5)\n",
    "\n",
    "println(I)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Diagonal Matrices**: Julia has a `Diagonal` type that stores only the diagonal elements of the matrix, making it memory-efficient and fast for certain operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a diagonal matrix\n",
    "d = Diagonal([1, 2, 3])\n",
    "\n",
    "println(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Block Diagonal Matrices**: Using the `BlockDiagonals` package (or other similar libraries), you can create block diagonal matrices that store each diagonal block separately."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "using BlockDiagonals\n",
    "\n",
    "# Create a block diagonal matrix\n",
    "D1 = Diagonal([1, 2, 3])\n",
    "D2 = Diagonal([3, 4, 5])\n",
    "BD = BlockDiagonal([D1, D2])\n",
    "\n",
    "println(BD)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Hermitian Matrices**: The `Hermitian` type in Julia is used for Hermitian matrices, which are complex square matrices that are equal to their own conjugate transpose."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a Hermitian matrix\n",
    "B = [1+im 2 3; 2 4 5; 3 5 6-im]\n",
    "H = Hermitian(B)\n",
    "\n",
    "println(H)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DataFrames\n",
    "The [DataFrames](https://github.com/JuliaData/DataFrames.jl) package provides a similar set of functionality to pandas in Python. We'll import the package and start by creating a simple DataFrame to experiment with."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "using DataFrames, Statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = DataFrame(Name=[\"John\", \"Jane\", \"Jim\"], Age=[28, 34, 45], Salary=[50000, 62000, 72000])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add a new column:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.Status = [\"Single\", \"Married\", \"Single\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's filter for people over 30..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filtered_df = filter(row -> row.Age > 30, df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `describe` function gives us some summary statistics..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "describe(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's also grouping and aggregate calculation functionality..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grouped = groupby(df, :Status)\n",
    "agg_df = combine(grouped, :Salary => mean => :AvgSalary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random Number (and more!) generation\n",
    "As with any self-respecting scientific programming language, Julia has extensive functionality for randomness. The core base function is `rand`, which we demonstrate in a few (of [many](https://docs.julialang.org/en/v1/stdlib/Random/)) variations below..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rand() # without arguments, will draw a single float from U(0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rand(3,2) # now make it a matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rand(Int, 2, 2) # we can also specify a type; now it will draw from the full range of values for that type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rand(['a', 'b', 'c']) # can also draw from a provided collection of objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rand(0:2:100) # anything iterable counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "randn(1,4) # draw from standard normal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Plots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us use `rand` and `randn` to generate and plot distributions..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate sample data for plotting\n",
    "normal_samples = randn(1000) * 2 .+ 5    # Normal distribution N(5, 2)\n",
    "uniform_samples = rand(1000) * 10       # Uniform distribution U(0, 10)\n",
    "\n",
    "# Plot histograms for comparison\n",
    "histogram(normal_samples, bins=30, alpha=0.5, label=\"Normal(5, 2)\", xlabel=\"Value\", ylabel=\"Frequency\")\n",
    "histogram!(uniform_samples, bins=30, alpha=0.5, label=\"Uniform(0, 10)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, we see the use of `!` in a slightly different way than was explored in the syntax section, though conceptually the same. The `histogram!` function modifies the existing plot, but we don't actually have to pass it as an argument (though we can), so the thing being modified \"in-place\" is not explicitly being passed in this case."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### More plot examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Line Plot**: A basic line plot with labels and title."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate some data\n",
    "x = 1:10\n",
    "y = x .^ 2\n",
    "\n",
    "# Line plot\n",
    "plot(x, y, label=\"y = x^2\", xlabel=\"x\", ylabel=\"y\", title=\"Line Plot\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Scatter Plot**: A scatter plot to show individual points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Scatter plot\n",
    "scatter(x, y, label=\"Scatter\", xlabel=\"x\", ylabel=\"y\", title=\"Scatter Plot\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Bar Plot**: A bar plot to visualize categorical data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Bar plot\n",
    "categories = [\"A\", \"B\", \"C\", \"D\"]\n",
    "values = [5, 9, 3, 7]\n",
    "\n",
    "bar(categories, values, label=\"Values\", title=\"Bar Plot\", xlabel=\"Category\", ylabel=\"Value\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Heatmap**: A heatmap to show a matrix of values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Heatmap data\n",
    "z = rand(10, 10)\n",
    "\n",
    "# Heatmap plot\n",
    "heatmap(z, title=\"Heatmap\", xlabel=\"X-axis\", ylabel=\"Y-axis\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Pie Chart**: A pie chart for visualizing proportions of categories."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pie chart data\n",
    "labels = [\"Category 1\", \"Category 2\", \"Category 3\"]\n",
    "sizes = [30, 45, 25]\n",
    "\n",
    "# Pie chart\n",
    "pie(sizes, labels=labels, title=\"Pie Chart\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3D Plot**: A 3D plot to visualize functions or data in three dimensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3D plot data\n",
    "x = -5:0.1:5\n",
    "y = -5:0.1:5\n",
    "z = [sin(sqrt(xi^2 + yi^2)) for xi in x, yi in y]\n",
    "\n",
    "# 3D surface plot\n",
    "plot(x, y, z, st=:surface, title=\"3D Plot\", xlabel=\"X\", ylabel=\"Y\", zlabel=\"Z\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**: The `Plots` package is a powerful and flexible plotting library in Julia, and it supports many different plot types and customization options. You can refer to the [Plots.jl documentation](http://docs.juliaplots.org/latest/) for more information on how to create different types of plots and customize them to suit your needs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unitful\n",
    "[Unitful.jl](https://painterqubits.github.io/Unitful.jl/stable/) is a Julia package for handling units and dimensions. It can be very useful for doing unit conversions and catching dimensional errors, but is also sometimes more trouble than it's worth to actually store every quantity in your code with units..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Unitful"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1.0u\"m/s\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1.0u\"N*m\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "u\"m,kg,s\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "typeof(1.0u\"m/s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "u\"ħ\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Converting between units"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert a `Unitful.Quantity` to different units. The conversion will fail if the target units a have a different dimension than the dimension of the quantity `x`. You can use this method to switch between equivalent representations of the same unit, like `N m` and `J`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "uconvert(u\"hr\",3602u\"s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "uconvert(u\"m/s\", 60u\"km/hr\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another useful function is: `upreferred`, which converts a quantity to the preferred unit for its dimension. In this case, units are converted to the preferred SI representation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "upreferred(u\"J\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also make `Unitful.Units` callable with a Number as an argument, for a unit conversion shorthand:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "u\"cm\"(1u\"m\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For syntax simplicity, we can use `|+>` (`|>`) to chain unit conversions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1u\"m\" |> u\"cm\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Dimensioless quantities"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For dimensionless quantities, we can use `NoUnits` as an argumert to `uconvert`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "uconvert(NoUnits, 1.0u\"μm/m\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also check if an object represents \"no units\" by doing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "unit(1.0) == NoUnits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible to convert a quantity to a subtype of `Real` or `Complex` to obtain the numerical value without units:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "convert(Float64, 1.0u\"μm/m\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dispatching on units"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following example shows how the `whatsit` function takes different types into account and returns the correct unit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "whatsit(x::Unitful.Voltage) = \"voltage!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "whatsit(x::Unitful.Length) = \"length!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "whatsit(1u\"mm\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "whatsit(1u\"kV\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Creating your own units"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If a different set of default units or dimensions is desired, macros for generating units and dimensions are provided. To create new units interactively, most users will be happy with the `@unit` macro and the `Unitful.register` function, which makes units defined in a module available to the `@u_str` string macro.\n",
    "\n",
    "An example of defining units in a module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "module MyUnits; \n",
    "\n",
    "using Unitful;\n",
    "\n",
    "@unit myMeter \"m\" MyMeter 1u\"m\" false; \n",
    "\n",
    "end\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MyUnits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Unitful"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After creating your own units in a module, you can try to use them, but this WILL NOT work until you register them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "u\"myMeter\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Unitful.register(MyUnits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1u\"myMeter\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create your own units and use them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Delimited Files**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Still in the context of manipulating numerical data, the [DelimitedFiles](https://docs.julialang.org/en/v1/stdlib/DelimitedFiles/) package provides functionality for reading and writing files with delimited values (Originally a Julia stdlib)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's read the file you just created:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "using DelimitedFiles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "readdlm(\"data/read_test.txt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also remove the header and specify the delimiter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "readdlm(\"data/read_test.txt\", ' ', Float64, comments=true)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.11.0-alpha2",
   "language": "julia",
   "name": "julia-1.11"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.11.0-alpha2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}