Engineering Analysis and Computation

Course Description

EGN2210C – Engineering Analysis and Computation is a 3-credit-hour engineering course that develops students' competency in computational methods for engineering analysis. The course covers programming for engineers (typically in MATLAB or Python at intermediate level beyond first-year introduction), numerical methods commonly used in engineering practice (root finding, numerical differentiation and integration, numerical solution of ordinary differential equations, linear algebra computations, optimization), and the application of these methods to engineering problems. The course bridges first-year engineering programming foundations with the more rigorous numerical methods coursework taken in upper-division engineering programs.

The "C" lab indicator denotes integrated lecture and laboratory components, with substantial hands-on programming work and the application of computational methods to engineering problems. Coursework typically combines lecture and example-based instruction with extensive programming projects, often including capstone-style projects analyzing real engineering problems through computation.

EGN2210C is a Florida common course offered at approximately 2 Florida institutions. The specific emphasis varies among institutions: some emphasize MATLAB programming and numerical methods; others emphasize Python and engineering data analysis; still others integrate symbolic computation. EGN2210C transfers as the equivalent course at all Florida public postsecondary institutions per SCNS articulation policy where the receiving institution accepts the course.

Learning Outcomes

Required Outcomes

Upon successful completion of this course, students will be able to:

• Apply programming for engineering computation at intermediate level (typically MATLAB or Python — institutional choice), including data types, arrays/matrices, control structures, functions, file I/O, and the use of standard libraries.
• Apply numerical computing fundamentals, including floating-point representation, machine epsilon, numerical error (round-off, truncation), the importance of numerical stability, and the awareness of the limitations of floating-point computation.
• Apply root finding methods, including the bisection method, Newton's method, and the secant method; the comparison of methods (rate of convergence, robustness); engineering applications.
• Apply linear algebra computations, including matrix operations; the solution of linear systems (LU decomposition, Gaussian elimination); the computation of eigenvalues and eigenvectors; the use of standard linear algebra libraries (NumPy, MATLAB built-in functions).
• Apply numerical differentiation, including forward, backward, and centered difference approximations; the choice of step size; engineering applications.
• Apply numerical integration, including the trapezoidal rule, Simpson's rule, and adaptive quadrature at introductory level; the integration of tabular data; engineering applications.
• Apply numerical solution of ordinary differential equations (ODEs), including Euler's method, the Runge-Kutta methods (RK2, RK4); the solution of initial value problems; engineering applications (motion problems, electrical circuit transients, chemical kinetics).
• Apply curve fitting and interpolation, including linear regression; polynomial regression; nonlinear curve fitting; interpolation (linear, polynomial, spline); the appropriate choice of method.
• Apply introductory numerical optimization, including the use of standard optimization functions (fminsearch in MATLAB, scipy.optimize in Python); engineering applications.
• Apply data visualization for engineering computation, including 2D plots, 3D plots, contour plots, and the design of effective visualizations.
• Apply computational engineering analysis through case studies, integrating multiple methods to solve substantive engineering problems.

Optional Outcomes

• Apply symbolic computation at introductory level (Symbolic Math Toolbox in MATLAB; SymPy in Python); the integration of symbolic and numerical computation.
• Apply introductory partial differential equations at conceptual level, including the finite difference method for simple PDE problems.
• Apply introductory simulation using engineering simulation tools (Simulink for MATLAB users; specialized simulation environments).
• Apply introductory finite element analysis (FEA) at conceptual level (where included).
• Apply principles to specific engineering analysis contexts reflecting the program's emphasis (mechanical: stress and motion; civil: structural analysis; electrical: circuit analysis; chemical: reaction kinetics).

Major Topics

Required Topics

• The Role of Computation in Engineering: The transition from analytical to computational engineering practice; the role of programming in modern engineering work; the engineering value of computational methods.
• Programming Foundations (MATLAB or Python): The interactive environment; data types (scalar, array, matrix, structure, cell); operators; control structures (if-else, for, while); functions (definition, parameters, return values); script vs. function files; file I/O.
• Numerical Computing Foundations: Floating-point representation (IEEE 754); machine epsilon; sources of numerical error (round-off in floating-point arithmetic; truncation in approximation methods); the awareness of numerical instability.
• Root Finding: The bisection method (guaranteed convergence, slow); Newton's method (fast convergence, requires derivative, may diverge); the secant method (fast convergence, no derivative needed); the choice of method; engineering applications (finding equilibrium positions, equilibrium concentrations, flow rates).
• Linear Algebra Computations: Matrix operations (addition, multiplication, transpose, inverse); the solution of linear systems Ax = b (LU decomposition, Gaussian elimination); the computation of eigenvalues and eigenvectors at introductory level; the use of MATLAB's backslash operator and Python's numpy.linalg functions.
• Numerical Differentiation: Forward difference (f'(x) ≈ [f(x+h) - f(x)]/h); backward difference; centered difference (f'(x) ≈ [f(x+h) - f(x-h)]/(2h)); the trade-off between truncation error (smaller h is better) and round-off error (larger h is better); the choice of step size.
• Numerical Integration: The trapezoidal rule (∫f(x) dx ≈ h[(f(a) + f(b))/2 + f(x_1) + ... + f(x_(n-1))]); Simpson's 1/3 rule (∫f(x) dx ≈ h/3 [f(a) + 4f(x_1) + 2f(x_2) + ... + f(b)]); adaptive quadrature at introductory level; the integration of tabular data; the use of standard library functions.
• Numerical Solution of ODEs: Initial value problems (dy/dt = f(t,y), y(0) = y₀); Euler's method (y_(n+1) = y_n + h·f(t_n, y_n)); Runge-Kutta methods (RK2, RK4 — improved accuracy); the trade-off between accuracy and computational cost; engineering applications.
• Curve Fitting: Linear regression (least squares); polynomial regression; the limitations of polynomial fits; nonlinear curve fitting (with example forms — exponential, power, logarithmic).
• Interpolation: Linear interpolation; polynomial interpolation (Lagrange interpolation); spline interpolation (cubic splines); the choice of interpolation method; the difference between interpolation and curve fitting.
• Introductory Optimization: The optimization problem; the use of MATLAB's fminsearch or fminunc; Python's scipy.optimize.minimize; the unconstrained vs. constrained optimization distinction at introductory level; engineering applications.
• Engineering Data Visualization: 2D plots (line, scatter, bar); 3D plots (surface, contour, mesh); the choice of plot type; effective visualization design (axis labels, legends, titles, color choice).
• Engineering Computational Case Studies: Substantive engineering problems integrating multiple methods — typical case studies might include the analysis of mechanical systems (motion under variable forcing); the simulation of electrical circuits (transient response); the modeling of chemical reactions; the analysis of structural systems; depending on program emphasis.

Optional Topics

• Symbolic Computation: Symbolic Math Toolbox (MATLAB) or SymPy (Python); symbolic differentiation, integration, equation solving; the integration of symbolic and numerical work.
• Introductory PDE Methods: The finite difference method for simple PDE problems (heat equation, wave equation at introductory level).
• Introductory Simulation: Simulink (for MATLAB users); the dynamic simulation paradigm; the engineering applications.
• Introductory FEA: The finite element method at conceptual level; the relationship to numerical analysis methods.
• Discipline-Specific Applications: Mechanical engineering (motion, vibrations, FEA preparation); civil engineering (structural analysis); electrical engineering (circuit transients, signal processing); chemical engineering (reaction kinetics, distillation).

Resources & Tools

• Common Texts: Numerical Methods for Engineers (Chapra/Canale — the most widely adopted text); MATLAB: An Introduction with Applications (Gilat); Python Programming and Numerical Methods: A Guide for Engineers and Scientists (Kong/Siauw/Bayen, free online); Applied Numerical Methods with MATLAB for Engineers and Scientists (Chapra)
• Online Platforms: Connect (McGraw-Hill — paired with Chapra); MathWorks online resources; Python Numerical Methods online textbook (free)
• Software: MATLAB (institutional licensing common in Florida engineering programs); Python (free, open source) with NumPy, SciPy, Matplotlib; Octave (free, mostly MATLAB-compatible)
• Reference Resources: MATLAB Onramp (free MathWorks training); the SciPy lecture notes (free); MIT OpenCourseWare numerical analysis courses; Numerical Recipes (Press/Teukolsky/Vetterling/Flannery — classic reference)

Career Pathways

EGN2210C provides foundational computational engineering skills that support career pathways across engineering disciplines:

• All Engineering Disciplines — Computational methods are increasingly central across all engineering specializations.
• Engineering Analysis Roles — Analysis-intensive engineering roles (FEA, CFD, simulation, modeling).
• R&D Engineering — Research and development roles requiring computational analysis.
• Engineering Software Development — Engineers developing engineering software tools.
• Engineering Data Analysis Bridge — Foundation for engineers transitioning toward data analytics roles.
• Graduate Engineering Study — Foundation for graduate work in computational engineering, applied mechanics, and similar areas.
• FE Exam Preparation — Computational and analytical content appears across FE exams.

Special Information

Variation Across Institutions

Because EGN2210C is offered at relatively few Florida institutions (approximately 2), the specific emphasis varies. Some institutions emphasize MATLAB programming with numerical methods; others emphasize Python with engineering data analysis; still others integrate symbolic computation as a substantial component. Students should consult their specific institution's current syllabus.

The Programming Language Question

Florida engineering programs are increasingly adopting Python as the engineering programming language, particularly for data-intensive engineering work. MATLAB remains the dominant choice in many traditional engineering analysis contexts (FEA, control systems, simulation). EGN2210C may use either depending on institutional emphasis. Both languages are valuable for engineering careers; students who develop proficiency in one typically can transfer skills to the other with focused effort.

General Education and Transfer

EGN2210C is a Florida common course number that transfers as the equivalent course at all Florida public postsecondary institutions per SCNS articulation policy where the receiving institution accepts the course.

Course Format

EGN2210C is offered in face-to-face, hybrid, and increasingly online formats. The programming-intensive nature of the course translates well to online delivery.

Position in the Engineering Curriculum

EGN2210C is typically taken in the second year of engineering study, after first-year engineering programming introduction (in EGN1001C/EGN1002C/EGN1007C or comparable). The course supports subsequent engineering coursework through the development of computational tools that engineers apply throughout their programs and careers.

Prerequisites

EGN2210C typically requires:

• First-year engineering course (EGN1001C, EGN1002C, EGN1007C, or comparable) with introductory programming exposure
• MAC2311 (Calculus I) and MAC2312 (Calculus II) with grades of C or better; some institutions require MAC2313 (Calculus III) and MAP2302 (Differential Equations)

Students should have current proficiency in calculus and basic programming before beginning EGN2210C.