Lesson 10-Advanced Programming and Performance Optimization

In-Depth Analysis of Object-Oriented Programming

Core Mechanisms of Classes and Objects

Complete Class Definition Example:

classdef (Sealed) SensorData
    % Property definitions (including validation)
    properties (Access = private)
        rawData_ (1,:) double {mustBeFinite} = []
        timestamp_ datetime
    end
    
    % Public properties
    properties (Dependent)
        processedData
        dataSummary
    end
    
    % Method definitions
    methods
        function obj = SensorData(data, time)
            % Constructor
            if nargin > 0
                obj.rawData_ = data;
                obj.timestamp_ = time;
            end
        end
        
        function value = get.processedData(obj)
            % Computed property getter
            value = smoothdata(obj.rawData_, 'gaussian');
        end
        
        function summary = get.dataSummary(obj)
            % Statistical summary
            summary.mean = mean(obj.processedData);
            summary.std = std(obj.processedData);
            summary.max = max(obj.processedData);
        end
        
        function plotData(obj)
            % Plotting method
            figure;
            plot(obj.timestamp_, obj.processedData);
            xlabel('Time'); ylabel('Processed Data');
            title('Sensor Data Visualization');
        end
    end
    
    % Event definitions
    events
        DataUpdated
    end
    
    % Event triggering methods
    methods
        function updateData(obj, newData)
            obj.rawData_ = newData;
            notify(obj, 'DataUpdated');  % Trigger event
        end
    end
end

Event-Driven Programming Example:

% Create object and subscribe to event
sensor = SensorData(rand(1,100), datetime('now'));
lh = addlistener(sensor, 'DataUpdated', @handleDataUpdate);

% Event callback function
function handleDataUpdate(src, ~)
    fprintf('Data updated at %s\n', datestr(now));
    src.plotData();  % Call object method
end

% Trigger event
sensor.updateData(rand(1,100));

Inheritance and Polymorphism Implementation

Abstract Class and Interface Design:

% Abstract base class definition
classdef (Abstract) DataProcessor
    methods (Abstract)
        processed = process(obj, rawData)  % Abstract method
    end
    
    methods
        function logProcessing(obj)
            fprintf('Data processing started at %s\n', datestr(now));
            obj.processed = obj.process(obj.rawData);
            fprintf('Data processing completed at %s\n', datestr(now));
        end
    end
end

% Concrete implementation class
classdef MovingAverageProcessor < DataProcessor
    properties
        windowSize = 5
    end
    
    methods
        function processed = process(obj, rawData)
            % Moving average implementation
            processed = movmean(rawData, obj.windowSize);
        end
    end
end

% Interface class (simulated via abstract class)
classdef (Abstract) LoggerInterface
    methods (Abstract)
        log(obj, message)
    end
end

Polymorphism Application Example:

% Create processor collection
processors = [MovingAverageProcessor(), ...
              MovingMedianProcessor()];  % Assuming other processors exist

% Polymorphic calls
data = rand(1,100);
for i = 1:length(processors)
    processedData = processors(i).process(data);
    processors(i).logProcessing();
end

Encapsulation and Access Control

Property Access Control Strategies:

classdef SecureDataContainer
    properties (Access = private)
        sensitiveData_ double
    end
    
    properties (Access = protected)
        internalState_ string
    end
    
    properties (Access = public)
        publicInfo string
    end
    
    methods
        function obj = SecureDataContainer(data)
            obj.sensitiveData_ = data;
            obj.internalState_ = 'initialized';
            obj.publicInfo = 'Public information';
        end
        
        % Controlled access method
        function value = getSensitiveData(obj, password)
            if strcmp(password, 'secret')
                value = obj.sensitiveData_;
            else
                error('Access denied');
            end
        end
        
        % Property validation
        function obj = setSensitiveData(obj, value)
            validateattributes(value, {'double'}, {'finite','nonempty'});
            obj.sensitiveData_ = value;
        end
    end
end

Design Pattern Implementation

Singleton Pattern Implementation:

classdef (Sealed) ConfigurationManager
    properties (Access = private)
        configData_ containers.Map
    end
    
    methods (Access = private)
        function obj = ConfigurationManager()
            % Private constructor
            obj.configData_ = containers.Map;
            obj.loadDefaultConfig();
        end
    end
    
    methods (Static)
        function instance = getInstance()
            % Static factory method
            persistent localObj
            if isempty(localObj)
                localObj = ConfigurationManager();
            end
            instance = localObj;
        end
    end
    
    methods
        function value = getConfig(obj, key)
            if isKey(obj.configData_, key)
                value = obj.configData_(key);
            else
                error('Configuration item does not exist');
            end
        end
        
        function setConfig(obj, key, value)
            obj.configData_(key) = value;
        end
    end
end

% Usage example
config = ConfigurationManager.getInstance();
config.setConfig('timeout', 100);
timeout = config.getConfig('timeout');

MATLAB vs C++ Object-Oriented Comparison

Key Differences Comparison Table:

FeatureMATLAB OOPC++ OOP
Class definition methodSingle file (classdef)Header file (.h) + implementation file (.cpp)
Inheritance modelSingle inheritance + interface simulationMultiple inheritance support
Virtual functionsSimulated via abstract methodsExplicit virtual keyword
Access controlpublic/protected/privatepublic/protected/private
Operator overloadingSupported (specific operators)Full support
TemplatesNot supportedFull template support
Exception handlingtry-catchtry-catch + exception class system
Memory managementAutomatic garbage collectionManual new/delete or smart pointers

Performance Engineering Practices

Vectorization and Memory Optimization

Large-Scale Data Processing Optimization:

% Inefficient loop example
result = zeros(1e6,1);
for i = 1:1e6
    result(i) = sqrt(i)*log(i+1);
end

% Vectorized optimization
i = (1:1e6)';
result = sqrt(i).*log(i+1);  % Fully vectorized

% Advanced memory preallocation
n = 1e8;  % Ultra-large scale data
chunkSize = 1e7;  % Chunk size
result = zeros(n,1);

for startIdx = 1:chunkSize:n
    endIdx = min(startIdx+chunkSize-1, n);
    % Process current chunk
    result(startIdx:endIdx) = arrayfun(@(x)sqrt(x)*log(x+1), startIdx:endIdx);
    clear tempVars;  % Clear temporary variables
    if mod(startIdx,1e8)==0
        fprintf('Processed %.2f%%\n', 100*startIdx/n);
    end
end

Parallel Computing Techniques

Multi-Core CPU Parallelization:

% Basic parfor example
n = 1e4;
results = zeros(n,1);

parfor (i = 1:n, 8)  % Specify 8 workers
    results(i) = monteCarloSimulation(i);
end

% SPMD distributed computing
spmd
    % Each worker has independent data
    localData = rand(1000, labindex);
    
    % Distributed computation
    localResult = svd(localData);
    
    % Collect results
    gatheredResults = gcat(localResult);
end

% Parallel pool configuration
pool = parpool('local',4);
pool.IdleTimeout = 3600;  % Idle timeout 1 hour

GPU Accelerated Computing

GPU Array Applications:

% Data transfer and computation
A = rand(10000);  % CPU array
A_gpu = gpuArray(A);  % Convert to GPU array

% GPU accelerated computation
B_gpu = fft(A_gpu);
C_gpu = A_gpu * B_gpu;

% Result transfer back
C = gather(C_gpu);

% Use pagefun for batch matrix operations
M = 100; N = 100;
matrixArray = rand(M,1000,1000);  % 3D array
matrixArray_gpu = gpuArray(matrixArray);

% Perform matrix multiplication on each slice of the third dimension
result_gpu = pagefun(@mtimes, matrixArray_gpu, matrixArray_gpu);

% Performance comparison
tic; C_cpu = A*A; toc
tic; C_gpu = A_gpu*A_gpu; toc

Distributed Computing Architecture

MATLAB Parallel Server Deployment:

% Cluster configuration
cluster = parcluster('slurm');  % Assuming SLURM scheduler
cluster.NumWorkers = 128;       % Request 128 workers

% Submit parallel job
job = batch('largeScaleSimulation', ...
    'Pool', 64, ...            % 64 workers per task
    'Cluster', cluster, ...
    'AdditionalPaths', {'/path/to/custom/code'});

% Monitor job status
wait(job);
results = load(job.OutputArguments{1});

Performance Analysis and Optimization

Code Profiling Techniques:

% Basic performance profiling
profile on
myComplexFunction(inputData);
profile viewer

% Precise timing
tic;
criticalSection();
elapsed = toc;
fprintf('Elapsed time: %.4f seconds\n', elapsed);

% Memory analysis
whos  % View workspace variables
clear largeArray  % Release large memory
memory  % Display memory status (requires Memory Profiler toolbox)

% Code acceleration suggestions
acceladvisor = matlab.codetools.codeaccelerator.Advisor;
report = acceladvisor.analyze('myScript.m');
report.show();

Code Generation and Deployment

MATLAB Compiler Application

Standalone Application Packaging:

% Compile to standalone executable
compiler.build.standaloneApplication('myApp.m', ...
    'AppName', 'DataAnalyzer', ...
    'OutputDir', 'deploy', ...
    'Version', '1.0.0', ...
    'EnableConsole', false);

% Create installer
compiler.build.installer('deploy/DataAnalyzer.exe', ...
    'InstallerName', 'DataAnalyzer_Installer', ...
    'OutputDir', 'installer');

MATLAB Coder Code Generation

C/C++ Code Generation Example:

% Function preparation (must meet code generation requirements)
function y = signalFilter(x, coeffs)
    % #codegen directive enables code generation
    %#codegen
    persistent filterState
    if isempty(filterState)
        filterState = zeros(length(coeffs)-1,1);
    end
    
    [y, filterState] = filter(coeffs, 1, x, filterState);
end

% Code generation configuration
cfg = coder.config('lib');  % Generate static library
cfg.TargetLang = 'C++';     % Target language
cfg.GenerateReport = true;  % Generate report

% Execute code generation
codegen('-config', cfg, 'signalFilter', ...
    '-args', {coder.typeof(0,[1 1000]), coder.typeof(0,[1 5])}, ...
    'OutputDir', 'generated_code');

Deployment Architecture Design

Embedded System Integration:

% Code generation options (embedded target)
cfg = coder.config('exe');
cfg.HardwareImplementation.ProdHWDeviceType = 'ARM Compatible->ARM Cortex';
cfg.TargetLang = 'C';
cfg.GenCodeOnly = false;

% Define interface specification
cfg.Interface = coder.interface('myAPI', ...
    'HeaderFile', 'api.h', ...
    'SourceFile', 'api.c');

% Generate portable code
codegen('-config', cfg, 'embeddedAlgorithm', ...
    '-args', {coder.typeof(0, [1 256])}, ...
    'OutputDir', 'embedded_code');

Web Application Deployment:

% Create Web App
appDesign = uifigure('Visible', 'off');
uibutton(appDesign, 'Text', 'Run Analysis', ...
    'Position', [100 100 100 30], ...
    'ButtonPushedFcn', @analyzeData);

% Package as Web App
webApp = compiler.package.webApp(appDesign, ...
    'AppName', 'DataVisualizer', ...
    'OutputDir', 'web_deploy');

% Deploy to MATLAB Web App Server
% (Import generated package in server management interface)
Share your love