Engineering Mathematics / Calculus Tutorial
Learn Engineering Mathematics / Calculus step by step: 68 lessons in 11 chapters with examples, quizzes, diagrams and projects.
Start learning →
of lessons completed
Getting Started
- What Is Engineering Mathematics? See why engineers rely on calculus, how limits, derivatives, integrals and differential equations fit together, and set up sympy, numpy and matplotlib.
- Functions and Graphs Review function notation, domain and range, composition, inverse functions and even/odd symmetry, and plot functions with numpy and matplotlib.
- The Algebra Toolkit for Calculus Refresh factoring, exponent and logarithm rules and key trig identities, then use sympy simplify, expand, factor and solve to check algebra and avoid slips.
Limits and Continuity
- Limits: The Core Idea Understand limits as the value a function approaches, use numeric tables and one-sided limits, handle infinity, and check results with sympy limit().
- Limit Laws and Tricks Compute limits with the limit laws, resolve 0/0 by factoring and conjugates, use the squeeze theorem, find limits at infinity, and verify with sympy.
- Continuity Learn the definition of continuity, the types of discontinuity, the intermediate value theorem, and write a bisection root finder in Python.
Derivatives
- The Derivative as a Rate of Change Learn the derivative as the limit of a difference quotient, the slope of a tangent line and an instantaneous velocity, with Python finite-difference checks.
- Differentiation Rules Learn the power, sum, product and quotient rules with a table of standard derivatives, and check every answer with sympy diff() and a numeric test.
- The Chain Rule Differentiate composite functions with the chain rule, handle nested chains, implicit differentiation and inverse functions, and avoid the usual mistakes.
- Derivatives of Exponentials, Logs and Trig Functions Derive and use the derivatives of e^x, ln x, sin, cos, tan and hyperbolic functions, and master logarithmic differentiation, with sympy and numeric checks.
- Rolle's and Mean Value Theorems Learn Rolle's theorem, the Mean Value Theorem and Cauchy's version, with the conditions that matter, worked examples and Python code that finds the point c.
- Applications of Derivatives Use derivatives to find increasing and decreasing intervals, maxima, minima and concavity, sketch curves, solve optimization and related-rates problems.
- Curve Tracing: Polar and Parametric Curves Sketch curves systematically: find asymptotes and symmetry, trace parametric and polar curves, compute slopes, areas and arc lengths, and plot them in Python.
- Unimodal and Bimodal Functions Learn unimodal and bimodal functions, why one peak makes optimisation easy, and how ternary and golden-section search find a minimum without derivatives.
- Linearization and Newton's Method Approximate functions with tangent lines, estimate errors with differentials, and solve equations with Newton's method, including when it fails to converge.
- Taylor and Maclaurin Series Approximate functions with polynomials: Taylor and Maclaurin series, the remainder, series for e^x, sin, cos and ln(1+x), sympy series() and plots.
Integrals
- The Integral as Accumulated Change Understand the definite integral as accumulated change: area under a curve, left, right and midpoint Riemann sums, and a numpy implementation.
- The Fundamental Theorem of Calculus Learn both parts of the Fundamental Theorem of Calculus: antiderivatives, evaluating definite integrals, net change, sympy integrate() and checks.
- Integration Techniques Master the main integration techniques: u-substitution, integration by parts, partial fractions and trig substitution, and learn when sympy beats hand work.
- Numerical Integration Compute integrals numerically with the trapezoid rule, Simpson's rule and adaptive quadrature using scipy.integrate.quad, and learn how errors behave.
- Improper Integrals and Convergence Handle improper integrals with infinite limits or singularities: limits, the p-test, comparison test, the Gaussian integral and series convergence tests.
- Gamma and Beta Functions Learn the Gamma and Beta functions: integral definitions, factorials, the half-integer values, the Beta-Gamma relation and how to evaluate tricky integrals in Python.
- Applications of Integrals Use definite integrals to find the area between curves, volumes of revolution, arc length, average value, work and centre of mass, with sympy and scipy checks.
Multivariable Calculus
- Vectors in 2D and 3D Learn vectors in two and three dimensions: dot and cross products, projections, lines and planes, with numpy and sympy examples you can run and change.
- Partial Derivatives Learn partial derivatives of functions of several variables: slopes along each axis, higher-order and mixed partials, the chain rule, and 3D surface plots.
- Homogeneous Functions and Euler's Theorem Understand homogeneous functions of degree n, test for homogeneity, apply Euler's theorem for partial derivatives, and check results with sympy in Python.
- Gradient and Directional Derivatives Understand the gradient vector, directional derivatives, steepest ascent, level curves and tangent planes, with runnable sympy, numpy and contour plot examples.
- Optimization in Several Variables Find minima, maxima and saddle points of functions of several variables with the Hessian test, use Lagrange multipliers for constraints, and run gradient descent.
- Double and Triple Integrals Learn double and triple integrals: iterated integrals, changing the order, polar, cylindrical and spherical coordinates, with sympy and scipy dblquad examples.
- Change of Variables in Multiple Integrals Learn the Jacobian determinant and change of variables for double and triple integrals, including polar, cylindrical and spherical coordinates, checked with SymPy.
- Vector Calculus: Divergence, Curl, Line Integrals Learn vector fields, divergence, curl, line and surface integrals, and the theorems of Green, Stokes and Gauss, with sympy and numpy checks you can run.
Differential Equations
- Ordinary Differential Equations: First Steps Start with ODEs: model change with equations, read direction fields, solve separable equations by hand, handle initial values and check answers with sympy dsolve.
- First-Order ODEs in Depth Solve linear first-order ODEs with an integrating factor, test for exact equations, and model growth, decay, mixing tanks and Newton cooling with sympy checks.
- Second-Order Linear ODEs Solve second-order linear ODEs with the characteristic equation, classify damping regimes, model spring-mass and RLC systems, and explore resonance in Python.
- Wronskian, Variation of Parameters and Cauchy-Euler Equations Use the Wronskian to test independent solutions, solve forced ODEs with variation of parameters, and handle Cauchy-Euler equations, checked with SymPy.
- Solving ODEs Numerically Build Euler and Runge-Kutta ODE solvers from scratch, see how step size, accuracy and stability interact, and use scipy solve_ivp for systems of equations.
- Power-Series Solutions: Bessel and Legendre Solve ODEs without closed forms using power series: ordinary points, Legendre polynomials, the Frobenius method and Bessel functions, with Python checks.
- The Laplace Transform Learn the Laplace transform, its key table and rules, solve initial value problems by algebra, and read transfer functions and step responses with sympy and scipy.
Series, Transforms and PDEs
- Sequences and Infinite Series Learn sequences, partial sums and infinite series: geometric and p-series, the ratio, comparison and alternating tests, power series and radius of convergence.
- Fourier Series Build periodic signals from sines and cosines: Fourier coefficients, the square wave, convergence, the Gibbs phenomenon and partial-sum plots in Python.
- The Fourier Transform and the FFT From Fourier series to the Fourier transform and the FFT: spectra, frequency bins, spectral leakage, windowing and filtering a noisy signal with NumPy.
- The Z-Transform and Difference Equations Learn the Z-transform, region of convergence, common pairs and the shift rule, then solve difference equations and check filter stability with Python.
- Complex Numbers and Phasors Rectangular and polar form, Euler's formula, roots of unity and phasors for AC circuit analysis, with cmath and NumPy examples you can run in the browser.
- Partial Differential Equations: Heat and Wave Meet the heat, wave and Laplace equations, solve them by separation of variables, and build a finite-difference heat solver with its stability limit in Python.
Linear Algebra and Numerical Methods
- Matrices and Linear Systems Matrix operations, Gaussian elimination, determinants, inverses and numpy.linalg.solve, plus why ill-conditioned systems give unreliable answers.
- Special Matrices, Determinants, the Adjoint and Cramer's Rule Recognize symmetric, skew-symmetric, orthogonal, idempotent, involutory and nilpotent matrices, use minors and cofactors, find inverses with the adjoint, and solve systems with Cramer's rule.
- LU Decomposition and Iterative Solvers (Jacobi, Gauss-Seidel, SOR) Factor a matrix as A = LU, solve many right-hand sides cheaply, and compare direct solving with the Jacobi, Gauss-Seidel and SOR iterations, including convergence conditions, in Python.
- Cayley-Hamilton Theorem and Matrix Functions Use the Cayley-Hamilton theorem to find inverses and high powers of a matrix, define functions of matrices such as exp(At) and solve linear ODE systems in Python.
- Eigenvalues and Eigenvectors in Engineering Learn eigenvalues and eigenvectors through diagonalization, system stability, vibration modes and principal stress axes, with numpy examples you can run.
- Root Finding and Interpolation Solve f(x) = 0 with bisection, secant and Newton methods, then fill gaps between data points with polynomial and spline interpolation in Python.
- Floating-Point Error and Conditioning Understand round-off, truncation error, catastrophic cancellation and condition numbers, learn stable formulas, and see how automatic differentiation works.
Probability and Statistics for Engineers
- Probability and Random Variables See probability as calculus: PDFs and CDFs as integrals, expectation and variance, the normal and exponential distributions, and scipy.stats in Python.
- Conditional Probability and Bayes' Theorem Learn conditional probability, the law of total probability and Bayes' theorem with a fault-diagnosis example, tree diagrams and Python simulation.
- Random Variables, Covariance and Correlation Learn discrete and continuous random variables, joint and marginal distributions, covariance and correlation, with worked tables and numpy simulations.
- Binomial, Poisson and Other Discrete Distributions Learn the binomial, geometric, Poisson and hypergeometric distributions: PMFs, means, variances, when each applies, and scipy.stats code for engineers.
- Gamma, Chi-Square and Student's t Distributions Learn the continuous distributions behind waiting times and statistical tests: gamma, chi-square and Student's t, with PDFs, means, variances, how they connect, and simulations.
- Poisson and Renewal Processes Model random arrivals over time: the Poisson process, exponential inter-arrival times, superposition, thinning and renewal counting, with simulations.
- Statistics, Curve Fitting and Uncertainty Derive least squares with calculus, fit lines and curves, build confidence intervals and propagate measurement uncertainty with derivatives in Python.
- Inferential Statistics for Engineers Learn to draw conclusions about a population from a sample: standard error, the central limit theorem, t confidence intervals, hypothesis tests, p-values, error types and power, with Python.
Projects
- Project: Projectile Motion with Air Drag Model a projectile with quadratic air drag as a system of ODEs, solve it with solve_ivp, find the optimal launch angle and compare it with the no-drag formula.
- Project: Simulating an RLC Circuit Build a series RLC circuit model from one second-order ODE: step response, resonance sweep, Laplace transfer function and phase plot, all in Python.
- Project: Heat Flow in a Rod Solve the 1D heat equation with finite differences in numpy, find the stability limit r = 0.5, then check the result against the Fourier-series solution.
- Project: Gradient Descent from Calculus Build gradient descent from first principles: derive loss gradients, tune the learning rate, add momentum, fit a line and a curve, verify with finite differences.
- Project: A Signal Analysis Lab Build a signal lab: synthesize a noisy signal, find its frequencies with the FFT, filter it, then integrate and differentiate numerically and measure the errors.
Practice and Review
- Common Mistakes in Calculus and How to Avoid Them The calculus errors that cost the most marks and the most bugs: dropped constants, chain rule slips, domain errors and unit errors, with sympy and numeric checks.
- Practice Exercises with Solutions Eighteen graded calculus problems on limits, derivatives, integrals, ODEs and series, each with a worked solution and a sympy check you can run in the browser.
- Interview Questions Practice calculus and engineering maths interview questions for engineering and data roles, with short answers and runnable sympy and numpy checks.
- Cheat Sheet A compact calculus and engineering maths cheat sheet: derivative and integral tables, Taylor series, Laplace and Fourier pairs, plus sympy and scipy one-liners.