View this on YouTube: https://youtu.be/RklM8O-gjk0 Here we do a simple proof that the general solutions to the time independent Schrodinger equation satisfy the time dependent Schrodinger equation in Quantum Physics. We do this by taking the general solution to the time independent Schrodinger equation and plugging it into the time dependent Schrodinger equation. What we find in the end is that we get out the time independent Schrodinger equation. This is very useful when learning Quantum physics.

All credit goes to Griffiths for writing a fantastic quantum mechanics textbook. In this video we work through part A of problem 1.5 out of Griffiths Quantum mechanics.

In this fifth video we cover the lu decomposition, which plays a crucial role in understanding how we can solve a linear system computationally. To do the lu decomposition we utilize the Structured Gaussian Elimination algorithm we discussed in the fourth episode. If you need a refresher here is a link to that video. https://youtu.be/59TAcVWZ0LY The 4th video's repo directories: https://github.com/nkphysics/Computational-Linear-Algebra-/tree/master/4_Structured_GE https://gitlab.com/n_space_cowboy/computational-linear-algebra/-/tree/master/4_Structured_GE The lu decomposition is a specific configuration of a matrix decomposition that allows us to show that the solutions to the upper triangular system we get from structured Gaussian elimination satisfy the original linear system Ax=b. We explore the lu decomposition computationally in the octave an python languages, utilizing numpy and scipy. This episodes directory in the series repo can be found in the following links. https://github.com/nkphysics/Computational-Linear-Algebra-/tree/master/5_LU_Decomposition https://gitlab.com/n_space_cowboy/computational-linear-algebra/-/tree/master/5_LU_Decomposition Understanding the lu decomposition if also crucial for understanding other matrix decompositions since it is one of the more general matrix decompositions. If you have any comments, questions or concerns feel free to let me know in the comment section.

In this video we discuss how we can speed up our Python code using Rust code, Pyo3 (a Rust crate), and a tool called Maturin. Python programs having slow performance is no secret. There are multiple ways that we can speed up our Python code, but one way to see our Python code perform better is to write a Python module in Rust. Rust is a beloved, low-level language, that has a reputation for being blazingly fast. Using a Rust crate called Pyo3 and a tool called Maturin we can easily take our Rust code and compile it into a Python module that we can easily use in our Python code. This will allow us to take advantage of Rust's blazingly fast speeds in Python. I explore these performance improvements by comparing random number generation between Python's standard random library, NumPy, and custom code written in Rust, Check out Pyo3: https://pyo3.rs/main/module.html Code used in this video: https://github.com/nkphysics/Exploring-Random Table of Contents: 00:00 - Introduction 01:33 - Quick disclaimer 01:58 - General overview or random number generators being used 02:29 - Using Pyo3 03:41 - Using Maturin 04:57 - Further description of the tests 05:42 - Performance with Python Lists 06:27 - Performance with NumPy arrays 07:50 - Performance with Rust Vectors 12:15 - Rust vectors vs optimal use of NumPy 12:51 - Conclusions