Understanding Kalman Filters: Intuitive Tutorial for Beginners

This comprehensive section covers the foundational concepts of linear algebra. Vectors are treated as column vectors (N×1 dimension) by default, with transpose notation 't' producing row vectors (1×N). Matrices are defined as tables of numbers, while tensors are multi-dimensional arrays. Matrix multiplication is defined for matrices A (M×N) and B (N×P), resulting in an M×P matrix where each element is computed as the sum of products of corresponding elements from rows of A and columns of B. The inner dimensions must match for multiplication to be defined. Matrix multiplication is associative: (AB)C = A(BC), but not commutative: AB ≠ BA in general. For two N×N matrices, standard multiplication requires N³ arithmetic operations. Matrix-vector multiplication (M×N matrix times N×1 vector) requires N² operations for square matrices. The order of multiplication matters significantly for computational efficiency—multiplying matrices before vectors is faster than multiplying matrices after vectors.

Linear algebra concerns linear equations and functions represented through matrices and vector spaces. A linear equation has the form a₁x₁ + ... + aₙxₙ = b. Vectors are tuples of scalars supporting addition, subtraction, scalar multiplication, and inner/dot product (row × column). Matrices are tuples of vectors supporting addition, subtraction, scalar multiplication, and matrix multiplication (where source columns match target rows). Matrix multiplication is not commutative. Square matrices have equal rows and columns; triangular matrices have zeros on one side of the diagonal. The identity matrix serves as multiplicative identity. The determinant represents the scaling factor of the linear transformation, and a matrix has an inverse if multiplying it by its inverse yields the identity matrix.

This comprehensive section covers three essential matrix operations. Determinants are only defined for square matrices: 2x2 uses AD-BC formula, 3x3 requires expansion along any row/column with sign alternation. Matrix transpose reverses order (rows to columns), with properties including double transpose returning original, transpose of scalar multiple, and transpose of product reversing order. Matrix inverse requires square matrices with non-zero determinant: A^(-1) = (1/det(A)) × adj(A). Singular matrices (det=0) have no inverse. For 2x2 [[a,b],[c,d]], inverse swaps diagonal elements and negates off-diagonal, then divides by determinant.

This comprehensive section covers the foundational concepts of linear algebra: (1) Determinant of upper triangular matrices equals the product of diagonal elements, (2) Matrix multiplication is associative (A×B×C = A×(B×C)), (3) Any matrix multiplied by zero matrix yields zero matrix, (4) Matrix multiplication requires columns of first matrix to equal rows of second matrix, (5) Skew-symmetric matrices satisfy A = -A^T, (6) A matrix is invertible if and only if its determinant is non-zero, (7) Matrix addition is commutative and associative, (8) Transpose distributes over addition: (A+B)^T = A^T + B^T, (9) Transpose reverses order in products: (AB)^T = B^T A^T, (10) Transpose of scalar multiple: (kA)^T = kA^T, (11) Transpose of transpose returns original: (A^T)^T = A, (12) Symmetric matrices satisfy A = A^T, (13) Identity matrices have 1s on diagonal and 0s elsewhere, (14) Diagonal matrices have non-zero elements only on the main diagonal, (15) The determinant of triangular matrices equals the product of diagonal elements, (16) The inverse is calculated as A^(-1) = (1/det(A)) × adj(A), (17) The adjugate matrix is found by computing minors for each element, applying checkerboard sign pattern, and transposing. These concepts form the foundation for understanding matrix operations and their applications in linear algebra.

Linear algebra provides compact representations for systems of linear equations using Ax = B notation. Vectors are arrays of real numbers, typically column vectors. Vector norms measure length satisfying four properties: non-negativity, definiteness, homogeneity, and triangle inequality. Common norms include L2 (Euclidean) and L1, with different penalties for errors. The inner product computes component-wise products summing to a scalar; orthogonal vectors have zero inner product. The cross product (3D only) produces a perpendicular vector following the right-hand rule. Matrices are rectangular arrays with m rows and n columns, classified by shape: square, wide/fat, tall/skinny. Upper triangular matrices have zeros below diagonal; lower triangular have zeros above. The transpose operation flips rows and columns, enabling symmetric (AT = A) and skew-symmetric (AT = -A) matrices. Matrix multiplication requires matching inner dimensions, producing outer dimensions. Properties include associativity, distributivity over addition, and non-commutativity. Transpose reverses product order: (ABC)T = CTBTAT. A square matrix is invertible if AA⁻¹ = I; if not, it's singular. Computing inverses is computationally expensive. Orthogonal matrices satisfy AT = A⁻¹, making inversion trivial (just transpose).

NumPy arrays are more efficient than Python lists for matrix operations. Create 2D matrices with np.array() using nested lists. For 3D arrays (useful for RGB images), combine three 2D matrices. Use .ndim to check dimensions. Create identity matrices with np.eye(n), zero matrices with np.zeros(shape), and ones matrices with np.ones(shape). Create 1D arrays with np.arange() or np.linspace(). Use np.reshape() to convert arrays between dimensions. Matrix addition/subtraction works element-wise with same shape. The * operator performs element-wise multiplication, while @ performs true matrix multiplication. Broadcasting allows operations on arrays of different shapes.

NumPy is a fundamental Python library for mathematical calculations and data management in scientific computing, statistics, and engineering. It provides efficient array operations essential for data science workflows. To use NumPy, install it using pip install numpy, then import it as np. Arrays differ from Python lists: arrays require uniform data types and fixed sizes, while lists allow mixed types and dynamic resizing. Arrays are 50 times faster for numerical computations. Arrays can have multiple dimensions: 0D (single scalar), 1D (single row), 2D (rows and columns), and 3D (stacked 2D arrays). The shape attribute shows dimensions, and dtype shows element types.

NumPy is a specialized Python package for scientific computing with multi-dimensional arrays. To use NumPy, import it using 'import numpy' or 'from numpy import *'. The core array creation function is numpy.array(), which takes a list of values and automatically infers the data type. If any element is a float (e.g., 5.0), all elements convert to float. You can explicitly specify the data type using dtype=int or dtype=float. This automatic type conversion ensures all array elements maintain the same data type, which is fundamental to NumPy's design for numerical computations.

NumPy (Numerical Python) is an open-source Python library created in 2005 by Travis Oliphant that provides powerful tools for scientific computing, including N-dimensional array objects, matrix operations, and specialized data types. Arrays in NumPy store elements of the same data type (unlike Python lists which can store mixed types), enabling efficient memory allocation and faster computations. Key concepts include creating arrays using np.array(), accessing elements through zero-based indexing, checking array properties like shape, dimensions, and size, and converting between data types using astype() method. The library supports various data types represented by single characters: 'i' for integer, 'f' for float, 'S' for string, 'b' for boolean, and 'c' for complex numbers.

NumPy is a Python library for numerical computing that provides support for large multi-dimensional arrays and matrices. To create a 1D array, use np.array([elements]). Access length using len(). The library enables efficient numerical computations that would be difficult with standard Python lists. Arrays can be named for easier reference in code. This foundation is essential for scientific computing and data analysis in Python.

Kinematics is the branch of mechanics that answers where a material point will be located and how it will move. A material point and particle are equivalent concepts. The position is described by the radius-vector as a function of time in a Cartesian coordinate system, specifying x, y, and z coordinates as functions of time. Velocity is found by taking the derivative of position: vx = dx/dt, vy = dy/dt, vz = dz/dt, with magnitude |v| = √(vx² + vy² + vz²). Acceleration is the derivative of velocity: ax = d(vx)/dt, ay = d(vy)/dt, az = d(vz)/dt. When initial position and acceleration are given as functions of time, integrate acceleration to find velocity: v = ∫a dt + v₀, then integrate velocity to find position: r = ∫v dt + r₀. When velocity or acceleration is given as functions of coordinates rather than time, use the definition of velocity to create differential equations and solve by separation of variables.

The three fundamental kinematic quantities are: (1) Position (x) - represents the distance traveled, unit is meter (m); (2) Velocity (v) - represents the rate of change of position, unit is meter per second (m/s); (3) Acceleration (a) - represents the rate of change of velocity, unit is meter per second squared (m/s²). These quantities are related through differentiation: velocity is the derivative of position with respect to time, and acceleration is the derivative of velocity with respect to time.

Kinematics is the branch of physics that describes motion without considering its causes, focusing on position, velocity, and acceleration as fundamental quantities. Position represents an object's location at a given instant, velocity is the rate of change of position (dx/dt), and acceleration is the rate of change of velocity (dv/dt). In uniform rectilinear motion (MRU), velocity remains constant, resulting in linear position-time graphs. In uniformly accelerated rectilinear motion (MRUV), acceleration is constant, producing parabolic position-time graphs. These concepts form the foundation for analyzing motion in one and two dimensions, with applications including free fall and projectile motion.

Kinematics is the study of motion without considering forces. Three fundamental quantities describe motion: position (X) describes location within a reference frame; velocity (V) describes how fast and in what direction something moves; and acceleration (A) describes how velocity changes over time. These concepts form the mathematical foundation for analyzing all types of motion.

This comprehensive section covers the mathematical foundations of kinematics. The instructor introduces reference frames (Laguerre for ground motion, Géocentrique for orbital motion) and explains the position vector with its three components (x, y, z) as functions of time. The velocity vector is defined as the first derivative of position, and acceleration as the derivative of velocity. The section demonstrates how to calculate these derivatives for specific functions and introduces integration to find position from velocity and velocity from acceleration, using initial conditions to determine integration constants. Linear functions and slope calculation are also covered as tools for describing constant velocity motion.