About the course
MATLAB is a powerful programming language and environment widely used in engineering, science, and finance for numerical computation, data analysis, and visualisation. This intensive 2-day workshop provides a comprehensive introduction to the essential fundamentals of MATLAB and its close counterpart, GNU Octave, equipping participants with the core skills to confidently perform calculations, manipulate data, and create visualisations in both environments.
The course covers working with the MATLAB/Octave environment, writing and executing script and function files, and mastering basic matrix and array operations, including an introduction to efficient vectorisation techniques. You will learn core programming concepts such as variables, fundamental data types (numeric, strings, cell arrays, structures), operators, control flow statements (if, for, while, switch), and essential data handling techniques including formatted input/output and importing/exporting data from various file formats. Debugging techniques and basic error handling are also covered to help you write robust code.
Key focus areas include creating and customising 2D and 3D plots for effective data visualisation, understanding and using different types of functions (including anonymous functions), and learning basic performance tuning concepts and techniques.
Please note you will need your own licensed MATLAB software. If you're happy to with command-line programming, you may wish to opt to use GNU Octave as a free alternative, as the code is largely compatible / portable. Through extensive hands-on exercises, you will gain practical experience applying these fundamentals to solve computational problems and analyse data.
Instructor-led online and in-house face-to-face options are available - as part of a wider customised training programme, or as a standalone workshop, on-site at your offices or at one of many flexible meeting spaces in the UK and around the World.
-
- Navigate the MATLAB/Octave environment and use the help system effectively.
- Create and execute script files and user-defined function files (.m files).
- Work with variables and fundamental data types, including matrices, arrays, strings, cell arrays, and structures.
- Perform basic matrix and array operations.
- Apply vectorisation techniques for writing efficient code.
- Implement control flow using if, for, while, and switch statements.
- Create and use user-defined functions, including anonymous functions.
- Perform basic data import and export from file formats like .mat and text files.
- Create and customise 2D and 3D plots for data visualisation.
- Use basic debugging techniques to troubleshoot code.
- Apply basic error handling (try-catch).
- Perform basic data analysis and statistics using built-in functions.
- Understand basic performance tuning concepts and use the Profiler.
-
This 2-day workshop is designed for anyone new to MATLAB or GNU Octave who need to learn their fundamentals for numerical computation, data analysis, and visualisation. It is ideal for:
Engineers
Scientists
Researchers
Students in technical fields
Data analysts
Anyone needing to perform mathematical computations, data analysis, or create plots using these environments.
-
Participants should have:
Experience navigating files, folders and have some experience of working with data (for instance using Excel)
Familiarity with a command-line or terminal interface will be beneficial but not strictly required.
Delegates must bring their own laptop with either licensed MATLAB software or GNU Octave installed and tested prior to the course.
No prior experience with MATLAB, Octave, or programming is required, although a basic understanding of mathematical concepts is helpful.
We can customise the training to match your team's experience and needs - with more time and coverage of fundamentals for new starters, or a swifter pace for experienced data analysts.
-
This MATLAB / Octave course is available for private / custom delivery for your team - as an in-house face-to-face workshop at your location of choice, or as online instructor-led training via MS Teams (or your own preferred platform).
Get in touch to find out how we can deliver tailored training which focuses on your project requirements and learning goals.
-
Introduction, Environment, and Basic Operations
What is Matlab? Its role in numerical computing, engineering, science, and finance.
The Matlab Environment: Overview of the Command Window, Workspace, and Editor (mention analogous components in GNU Octave).
Getting Help: Effective use of help and doc commands.
Working with Variables: Naming conventions, assignment, and data types (numeric types like double, single, integer).
Creating and Running Script Files (.m scripts): Writing sequences of commands.
Building Matrices and Arrays: Direct input, using colon operator, generating special matrices (zeros, ones, eye, rand, randn).
Addressing and Assigning Elements: Using linear and subscript indexing, the colon operator for ranges and subsets.
Basic Matrix and Array Operations: Element-wise operations (.*, ./, .^) vs. matrix multiplication (*).
Solving Systems of Linear Equations (using matrix division \ or /).
Introduction to Vectorisation: Performing operations on entire arrays without explicit loops for efficiency.
Hands-On Lab: Navigating the environment, creating/manipulating matrices and arrays, writing and running simple scripts, initial vectorisation exercises.
Control Flow, Functions, and Basic Data Handling
Operators: Arithmetic operators, Relational operators (==, ~=, >, <, >=, <=), Logical operators (&&, ||, ~, &, |), operator precedence.
Control Flow Statements:
if-else-end: Conditional execution.
switch-case-otherwise-end: Handling multiple conditions.
for loops: Iterating a fixed number of times.
while loops: Looping based on a condition.
User-Defined Functions:
Creating and Running Function Files (.m functions): Defining functions with input and output arguments.
Understanding function scope.
Anonymous Functions: Creating simple, single-line functions.
Function Handles: Passing functions as arguments (brief introduction).
Precision Issues: Understanding floating-point arithmetic limitations.
Additional Fundamental Data Types:
Character Arrays and Strings.
Cell Arrays: Holding different types of data.
Structures: Organising data with field names.
Basic Error Handling: Using try-catch blocks for graceful error management.
Formatted Input/Output: Displaying variables and text (disp, fprintf), reading console input (input), basic file output (fprintf).
Hands-On Lab: Writing scripts and functions using control flow, working with strings, cell arrays, and structures, implementing basic error handling.
Data Import/Export, Plotting Fundamentals
Data Import and Export:
Loading and Saving .mat files (load, save): Storing and retrieving variables.
Reading and Writing Text Files: Using functions like readmatrix, writematrix (or compatible loadtxt, savetxt in Octave), or lower-level file I/O (fopen, fclose, fprintf, fscanf) for broader compatibility.
Reading Data from other common formats (e.g., CSV, basic Excel files) using high-level functions (readtable). Focus on compatible methods.
Plotting 1:
Creating 2D plots (plot).
Customising plot appearance: Adding titles, labels, legends, changing colours, line styles, and markers.
Plotting multiple datasets on the same axes.
Creating subplots.
Debugging Code: Using the Matlab/Octave debugger: Setting and clearing breakpoints, running to breakpoints, stepping through code (step in, step over, step out), inspecting variables in the workspace during debugging.
Hands-On Lab: Importing/exporting data from various file types, creating and customising 2D plots, practising debugging techniques on sample code.
Advanced Topics and Performance
User Defined Functions 2: (Going deeper into function writing)
Variable number of input and output arguments (varargin, varargout).
Subfunctions and nested functions (brief overview).
Plotting 2: (More advanced visualisation)
Creating 3D plots (plot3, surf, mesh).
Working with multiple figures and axes.
Basic handle graphics concepts (if time permits).
Matlab Performance Tuning & Vectorisation Revisited:
Understanding code execution time (tic, toc).
Using the Profiler to identify performance bottlenecks in your code.
Practical techniques for writing faster code: Pre-allocation, more advanced vectorisation examples (e.g., using logical indexing effectively, arrayfun / cellfun for applying functions to array elements).
Set Functions: Using functions like unique, intersect, union, setdiff for array manipulation.
Basic Data Analysis & Statistics: Using built-in functions for common statistical calculations (mean, median, std, max, min, sum), sorting data (sort), finding elements (find, logical indexing).
Utility Commands Revisited: More advanced commands for managing the workspace (whos, clear, clc), file system interaction, timing code.
Hands-On Labs: Creating advanced plots, optimising simple code snippets using performance techniques, applying set functions and statistical functions.
-
Official MATLAB Documentation - https://uk.mathworks.com/help/matlab/
GNU Octave Website - https://www.gnu.org/software/octave/
GNU Octave Documentation - https://www.google.com/search?q=https://www.gnu.org/software/octave/doc/index.html
Trusted by
