ENGGEN 131 Introduction to Engineering Computation and Software Development
The Complete Exam Bible · S2 2026ENGGEN 131 Overview
- University of Auckland
- Semester Two 2026
- Level 1 engineering
- MATLAB and C programming
- Final exam must be sat
ENGGEN 131 introduces engineering computation through two programming environments. The first half develops MATLAB from variables, scripts and functions through logic, debugging, arrays, matrices, images, text, files, function handles, numerical solvers and efficiency.
- Assessed by Laboratories, projects, assignments, two tests and a final exam
- Hardest step Tracing state across array, function and pointer boundaries
- How to prepare Predict outputs by hand, then challenge each boundary
What you get in the full ENGGEN 131 Exam Bible
- 10 chapters, 43 pages — every examinable topic
- 32 original practice questions, each with a model answer in the Final Exam format
- 10 worked examples, solved the way ENGGEN 131 marks
- 20 computed figures, redrawn from the course’s own numbers
- Exam-morning plan for the Final Exam (40%) — what to revise last, where marks are lost
Free on this page: assessment table, chapter map, one worked example, key terms, FAQ. The rest is in the full exam bible.
How ENGGEN 131 is assessed
| Component | Weight | Format |
|---|---|---|
| Laboratories | 10% | Ten individual laboratory submissions, each worth 1%; Lane 2 uncontrolled |
| Projects | 16% | Two individual programming projects, each worth 8%; Lane 2 uncontrolled |
| Assignments | 4% | Five smaller assignments with individual weights of 0.5% or 1%; Lane 2 uncontrolled |
| Tests | 30% | Two in-person controlled tests, each worth 15% and scheduled for 90 minutes plus reading time |
| Final Exam · hurdle | 40% | Controlled final examination; sitting the exam is a published passing condition |
Weights and passing conditions come from the Semester Two 2026 Canvas course assessment page. Final-exam attendance is required to pass; a numeric attendance threshold is not published. Students must also earn at least 40% of weighted Lane 1 marks and at least 50% overall after rounding to pass. Confirm the conditions and their consequences in Canvas. The five numeric assessment rows sum to 100%.
Assessment structure
Coursework contributes 30%, the two tests contribute 30%, and the final exam contributes 40%.
What other students are asking about ENGGEN 131
- Where can I find lecture notes or study guides for ENGGEN 131 at Auckland?
- The ENGGEN 131 study guide in AskSia Library covers Introduction to Engineering Computation and Software Development in 10 chapters, with the assessment table, a chapter-by-chapter topic map, key terms and a worked example, free to read on this page.
- Is there a final exam in ENGGEN 131, and how much is it worth?
- Yes. In the offering this AskSia Library guide is built from, Final Exam carries 40% of the ENGGEN 131 mark; the full split is Laboratories 10%, Projects 16%, Assignments 4%, Tests 30%, Final Exam 40%.
- What does ENGGEN 131 cover on conditionals, problem solving and debugging?
- In AskSia Library's ENGGEN 131 guide, the Conditionals, Problem Solving and Debugging chapter explains boolean logic, boundary decisions, test design and first-mismatch debugging.
- What does ENGGEN 131 cover on matlab arrays and loops?
- In AskSia Library's ENGGEN 131 guide, the MATLAB Arrays and Loops chapter explains array shape, indexing, elementwise operators, loop traces and invariants.
- What does ENGGEN 131 cover on matrices, images and transformations?
- In AskSia Library's ENGGEN 131 guide, the Matrices, Images and Transformations chapter explains row-column coordinates, image intensities, thresholds and dimension checks.
Current ENGGEN 131 dates
| Date | Item | Control |
|---|---|---|
| 24 Aug 2026 | MATLAB test | Current Canvas schedule |
| 15 Oct 2026 | C test | Current Canvas schedule |
| 02 Nov 2026 | Final exam | Current Canvas exam assignment |
Dates are as published in the current course materials. Confirm exact deadlines and submission settings in the live LMS.
What ENGGEN 131 covers
The course begins with MATLAB scripts, functions, decisions, arrays and engineering data, then transfers the same problem-solving discipline into C types, memory, pointers, files and recursion.
MATLAB Scripts and Functions
Variables, scripts, function contracts, local workspaces and returned valuesThis chapter separates MATLAB console work, scripts and functions by the state each can see. It develops explicit input-output contracts, local function workspaces, return values, scalar expansion and trace tables.
- Base workspace and local function workspace
- Scripts for orchestration and functions for reusable transformations
- Function headers, input order and returned outputs
- Right-to-left evaluation of assignments
- Contract tests using simple and boundary inputs
Conditionals, Problem Solving and Debugging
Boolean logic, boundary decisions, test design and first-mismatch debuggingThis chapter translates engineering requirements into Boolean expressions and mutually exclusive branches. It emphasises inclusive and exclusive endpoints, scalar versus array logic, branch ordering and the first-mismatch method of debugging.
- Relational operators and Boolean results
- AND, OR and explicit grouping
- If, elseif and else branch order
- Boundary tables for included endpoints
- Syntax, run-time and logic error evidence
MATLAB Arrays and Loops
Array shape, indexing, elementwise operators, loop traces and invariantsThis chapter treats an array as values plus shape and legal positions. It covers one-based indexing, colon sequences, linspace, row and column orientation, matrix versus elementwise operators, for and while loops, trace tables and loop invariants.
- Row vectors, column vectors and dimensions
- Colon sequences and evenly spaced points
- Scalar, range and logical indexing
- Matrix and elementwise arithmetic
- For loops, while loops and invariants
Matrices, Images and Transformations
Row-column coordinates, image intensities, thresholds and dimension checksThis chapter connects matrix coordinates with image pixels. It develops row-column indexing, full-row and full-column selection, dimension prediction, grayscale ranges, thresholding and the choice between elementwise transformations and matrix multiplication.
- Row and column subscripts
- Full-row and full-column selection
- Image intensity matrices and data range
- Threshold and brightness transformations
- Dimension compatibility for matrix multiplication
Text Data and File Processing
Character representation, text comparison, parsing and checked file loopsThis chapter separates character values, character vectors and string values before applying comparison, indexing or conversion. It then builds a checked file-processing loop around open validation, successful reads, parsing, state updates and closure.
- Character codes and case conversion
- Character vectors and string values
- Whole-text versus element comparison
- Open, read, parse, update and close
- Blank, malformed and empty-file cases
Function Handles, ODEs and Efficiency
Function handles, numerical solvers, trajectory reasoning and fair timingThis chapter shows how function handles carry callable behaviour into root finders, minimisers and ordinary differential equation solvers. It matches solver signatures, reads adaptive output arrays, reasons from derivative sign and tests equilibrium behaviour.
- Named and anonymous function handles
- Solver input signatures and output shapes
- Derivative sign and qualitative trajectories
- Adaptive time points and paired state arrays
- Correctness checks before timing comparisons
C Types, Operators and Standard I/O
Declared types, conversion order, integer division and format contractsThis chapter makes C evaluation rules explicit through declarations, operand types, integer division, conversions, precedence and formatted input-output.
- Integer, floating and character types
- Integer division and mixed expressions
- Cast placement and conversion order
- Assignment, equality and precedence
- Format specifiers, addresses and conversion counts
C Loops, Arrays and Functions
Zero-based boundaries, reductions, function contracts and array mutationThis chapter develops zero-based C array traversal, explicit length contracts, reductions, scalar pass-by-value and array mutation through shared element storage.
- Zero-based legal index domains
- Array parameters and explicit lengths
- For-loop boundaries and iteration counts
- Reduction initialisation from valid data
- Scalar copies and array element mutation
Pointers, Parameter Passing and 2D Arrays
Addresses, dereferencing, caller mutation and row-major array layoutThis chapter draws pointers as stored addresses leading to typed objects. It separates pointer assignment from dereferenced assignment, explains caller mutation through address parameters and checks target validity and lifetime before every dereference.
- Address-of and dereference operators
- Pointer value versus target value
- Mutation through address parameters
- Null, uninitialised and stale pointers
- Row-major two-dimensional array layout
Strings, Files and Recursion
Null termination, successful-read loops, base cases and return orderThis chapter treats a C string as a character array terminated by a null character and distinguishes visible length from capacity.
- Visible string length and array capacity
- Null termination and safe construction
- Successful-read file loops
- Recursive base cases and progress
- Call order and return order
The second half moves the same problem-solving habits into C, where declared types, standard input and output, loops, arrays, functions, pointers, strings, file processing and recursion make memory and boundaries more explicit.
The course is practice-heavy: ten laboratories build weekly fluency, two projects require larger programs, smaller assignments target integrity, style and preparation, two controlled tests check rapid reasoning, and a final exam completes the assessment. The published weights are Laboratories 10%, Projects 16%, Assignments 4%, Tests 30% and Final Exam 40%.
Final-exam attendance is required to pass; a numeric attendance threshold is not published. Students must also earn at least 40% of weighted Lane 1 marks and at least 50% overall after rounding to pass. Confirm these published passing conditions and their consequences in Canvas.
This guide therefore emphasises the facts that make the course demanding without inventing a difficulty rating: code must be read accurately by hand, array boundaries change between MATLAB and C, small operator choices alter meaning, and a program that runs can still fail its contract. Each chapter uses original examples and adversarial tests.
The recurring method is to state the input-output contract, map the relevant state, trace one statement at a time, test a boundary and locate the first mismatch. Released test material informs the question types, but no University question stem is reproduced here.
Worked example · free
Trace an array maximum without a zero bias
- 1Initialise the candidate from the first valid element, so best starts at -4.
- 1Compare -9 with -4. The candidate remains -4.
- 1Compare -2 with -4. The candidate becomes -2.
- 1Return -2. A zero initial value would return a number that is not present in the all-negative input.
Key terms
- Array index
- A position used to select an array element; MATLAB begins at one while C begins at zero.
- Base case
- The recursive condition that returns directly and stops further calls.
- Boolean expression
- An expression whose result is true or false and controls a branch or loop.
- Dereference
- The operation of following a pointer address to access its target object.
- Elementwise operator
- A MATLAB operator that applies independently to corresponding array elements.
- Function handle
- A MATLAB value that refers to callable behaviour and can be passed into another function.
- Loop invariant
- A statement that remains true after every completed loop iteration and supports correctness.
- Null character
- The zero-valued character that terminates a valid C string.
- Pointer
- A typed C variable whose stored value is an address.
- Row-major order
- The C array layout in which the elements of one row are contiguous before the next row.
- Scalar expansion
- MATLAB behaviour that applies a scalar operation across every compatible array element.
- Workspace
- The set of named values visible in a MATLAB execution context, such as the base or a function workspace.
ENGGEN 131 FAQ
How hard is ENGGEN 131?
The published assessment makes the pressure concrete: two controlled tests contribute 30% and the final contributes 40%, while laboratories and projects require steady programming practice. The recurring challenge is switching from MATLAB's one-based array model to C's explicit types, zero-based bounds and pointers without losing the underlying problem-solving method.
What are the assessment and passing conditions?
Laboratories contribute 10%, projects 16%, assignments 4%, tests 30% and the final exam 40%. Final-exam attendance is required to pass; a numeric attendance threshold is not published. Students must also earn at least 40% of weighted Lane 1 marks and at least 50% overall after rounding to pass. Confirm these conditions and their consequences in Canvas.
What does the MATLAB test look like?
The current Canvas page describes an in-person, 90-minute test consisting of 25 single-best-answer multiple-choice questions. It covers the MATLAB material identified on the course page and is completed on paper. Current instructions prohibit electronic devices, including calculators, so practise short traces and arithmetic without relying on software.
What is confirmed about the final exam?
The Canvas assignment schedules the Semester Two 2026 final for 2 November at 9am and gives it a 40% weight. The current FAQ says calculators are not permitted. The captured folder does not contain the linked format page, so confirm duration, sections, question types, venue and any other aids on the live Canvas page.
How should I revise MATLAB?
Trace scripts and functions with separate workspaces, expand array indices before selecting values, write array dimensions beside expressions and distinguish matrix from elementwise operators. Then rehearse condition boundaries, loops, text processing, file reads and function handles using tiny inputs whose correct results can be computed by hand.
How should I revise C?
Annotate every expression with its operand types, list legal indices before writing a loop and draw pointer arrows before dereferencing. For strings, reserve space for the null character; for files, drive loops with successful reads; for recursion, prove that the argument reaches a base case and trace returns upward.
Can AI help me prepare?
Use AI to request explanations, fresh practice and feedback on your reasoning before an assessment. Keep your own trace visible and verify outputs against the course methods. The course materials classify the controlled tests as work where generative AI is not permitted, so preparation and assessment use must remain clearly separated.
Questions students ask in each ENGGEN 131 chapter
- When should I write a function instead of a script?
- Use a function when a calculation should have explicit inputs and outputs, be reusable or be tested independently without relying on unrelated base-workspace names. This boundary makes isolated tests dependable. Chapter 01 · MATLAB Scripts and Functions
- Why can separate if statements be wrong?
- Each independent condition is evaluated, so more than one body can execute. Use an exclusive chain when exactly one category should apply. Rehearse this distinction with a fresh interval and branch trace before relying on program output. Chapter 02 · Conditionals, Problem Solving and Debugging
- Why does MATLAB indexing begin at one?
- MATLAB defines the first array position as one, so index calculations and loop bounds must follow that convention consistently. Rehearse this distinction with a fresh index and loop-state trace before relying on program output. Chapter 03 · MATLAB Arrays and Loops
- What does A(:,3) select?
- It selects every row in column three and returns a column containing those entries. Rehearse this distinction with a fresh coordinate and dimension trace before relying on program output. Chapter 04 · Matrices, Images and Transformations
- Why normalise letter case?
- Normalising case before comparison makes the policy explicit and avoids rejecting an otherwise valid spelling that differs only by uppercase or lowercase letters. Rehearse this distinction with a fresh text and record-boundary trace before relying on program output. Chapter 05 · Text Data and File Processing
- Why are solver time points uneven?
- Adaptive solvers choose step sizes based on numerical needs, so interpret state values against the returned time array rather than an assumed fixed interval. Rehearse this distinction with a fresh model and solver-contract trace before relying on program output. Chapter 06 · Function Handles, ODEs and Efficiency
- Why did storing in double not preserve the fraction?
- If integer division happened first, the fraction was discarded before assignment. The destination type converts only the completed integer result. Rehearse this distinction with a fresh type and conversion trace before relying on program output. Chapter 07 · C Types, Operators and Standard I/O
- What are the legal indices for length n?
- They run from zero through n minus one. The value n is the first position outside the array. Rehearse this distinction with a fresh array-boundary and invariant trace before relying on program output. Chapter 08 · C Loops, Arrays and Functions
- Does C pass arguments by reference?
- C passes values. Passing an address copies the pointer value, and both the caller and function can then identify the same target object. Rehearse this distinction with a fresh object and pointer-lifetime trace before relying on program output. Chapter 09 · Pointers, Parameter Passing and 2D Arrays
- Why does a four-character word need five elements?
- The four visible characters require one additional array element for the terminating null character. Rehearse this distinction with a fresh termination and memory-boundary trace before relying on program output. Chapter 10 · Strings, Files and Recursion
How to study for the exam
Use the weekly course structure as a cumulative practice loop. Before a laboratory, read the relevant chapter and hand-trace one small example. During the lab, separate the input contract, computation and output so each part can be tested. After submission, keep a short error log naming the mistaken assumption, the test that exposed it and the corrected rule.
Before the MATLAB test, practise twenty-five compact traces under a ninety-minute limit, with special attention to one-based indexing, operator dots, branch endpoints and loop updates. When the course moves to C, translate familiar algorithms while explicitly adding types, zero-based domains, addresses and lifetimes. Build a paper memory map for pointers and strings instead of relying on intuition.
For final revision, interleave languages: solve one MATLAB array problem, one C type problem, one pointer trace and one recursion trace in each session. Use released papers to identify question types, but write fresh inputs so recognition cannot substitute for reasoning. Check the live Canvas pages for the final format and permitted materials.