Course Code: 20EC0454 R20

SIDDHARTH INSTITUTE OF ENGINEERING & TECHNOLOGY

(AUTONOMOUS)
(Approved by AICTE, New Delhi& Affiliated to JNTUA, Ananthapuramu)
(Accredited by NBA for Civil, EEE, Mech., ECE & CSE)
(Accredited by NAAC with ‘A+’ Grade)
Puttur -517583, Tirupati District, A.P. (India)
QUESTION BANK WITH SOLUTION
Subject with MATLABPROGRAMMING Course & B.Tech. – CSE, CSIT
Code (20EC0454) Branch
Year & Sem IV-B.Tech.&I-Sem Regulation R20
UNIT-III
FUNCTIONS AND FILES
1.a. Discuss about Exponential and Logarithmic Functions in elementary mathematical function with
appropriate commands. [L1][CO1][6M]
Exponential and Logarithmic Functions
MATLAB has functions for computing exponents and logarithms for real and complex numbers.
• Exponential Function:
o Command: exp(x)
o Description: Computes e^x, where e is the base of natural logarithms (approximately
2.7183).
o Example:
result = exp(2); % Result is approximately 7.3891 (e^2)
• Natural Logarithm (Base e ):
o Command: log(x)
o Description: Computes the natural logarithm ln(x)\ln(x).
o Example:
result = log(10); % Result is approximately 2.3026
• Base-10 Logarithm:
o Command: log10(x)
o Description: Computes the base-10 logarithm log10(x).
o Example:
result = log10(100); % Result is 2, because log10(100) = 2
• Base-2 Logarithm:
o Command: log2(x)
o Description: Computes the base-2 logarithm log2(x).
o Example:
result = log2(8); % Result is 3, because log2(8) = 3
1.b. Compute the following using MATLAB commands.
a)√−144
b) 𝑒 3𝑦
c) log10(2y)
d) log (-4x). [L3][CO2][6M]
a) √−𝟏𝟒𝟒
Since √−144 involves the square root of a negative number, the result will be a complex number.
MATLAB Command:
Res=sqrt(-144);
disp(Res);
Result : 12i
Course Code: 20EC0454 R20
b) 𝒆𝟑𝒚
MATLAB Command :
Y=[1 , 2] ;
res=exp(3 * y);
disp(res);
Result : 20.0855 403.4288
Explaination : The command exp(3 * y) calculates the exponential of each element in 3 * y,
which means it computes exp(3×1) and exp(3×2) for y = [1, 2]
C) log10(2y)
MATLAB Command :
Y=[1 , 2 , 3] ;
res=log10(2 * y);
disp(res);
Result : 0.3010 0.6021 0.7782
Explaination : The command log10(2 * y) calculates the base-10 logarithm of each element in
2 * y, which means it computes log10(2×1), log10(2×2), and log10(2×3) for y = [1, 2, 3]
d) log (-4x).
MATLAB Command :
X = 5;
res=log(-4 * x);
disp(res);
Result : 3.0445 + 3.1416i
Explaination : The command log(-4 * x) calculates the natural logarithm of -4 * x, which is
log(−20) when x=5.
Since the logarithm of a negative number results in a complex number, MATLAB will return a complex
output.
2. a. Explain how complex functions are handled by MATLAB. Give some examples.
In MATLAB, a complex function is any function or operation that can handle and manipulate complex
numbers, which have both real and imaginary parts. Complex numbers in MATLAB are represented as
a+bi or a+bj, where a is the real part, b is the imaginary part, and i or j represents the imaginary unit
(equivalent to √−1 ).
Creating a Complex Number
Syntax: z = a + bi or z = complex(a, b)
Here are some common functions and examples that demonstrate how MATLAB handles complex
functions:
1. abs – Absolute Value (Magnitude)
The abs function in MATLAB returns the magnitude (or modulus) of a complex number, which is
the distance from the origin to the point in the complex plane.
Example:
z = 3 + 4i;
magnitude = abs(z); % Result: magnitude = 5
In this example, the magnitude of z=3+4i is √32 + 42 =5 .
2. angle – Phase Angle
The angle function returns the phase angle (or argument) of a complex number, which is the angle
in radians between the positive real axis and the line connecting the origin to the point.
Example:
z = 3 + 4i;
theta = angle(z); % Result: theta ≈ 0.9273 radians
Course Code: 20EC0454 R20
Here, the phase angle for z=3+4i is approximately 0.9273 radians.
3. real and imag – Real and Imaginary Parts
The real function extracts the real part of a complex number, while imag extracts the imaginary
part.
Example:
z = 5 - 2i;
real_part = real(z); % Result: real_part = 5
imaginary_part = imag(z); % Result: imaginary_part = -2
In this case, real_part is 5, and imaginary_part is -2 for z=5−2i.
2. b. Explain the following MATLAB commands with suitable examples.
a)The round function,
b) The ceilfunction,
c) The floor function.
a) The round Function
Definition: The round function rounds a number to the nearest integer. If the fractional part of the
number is exactly 0.5, MATLAB rounds to the nearest even integer.
Syntax: round(x)
Examples:
->x = 3.6;
y = round(x); % Result: y = 4
Here, 3.6 rounds up to the nearest integer, 4.
-> x = 3.4;
y = round(x); % Result: y = 3
Here, 3.4 rounds down to the nearest integer, 3.
b) The ceil Function
Definition: The ceil function rounds each element of x to the nearest integer greater than or equal to
that element, also known as rounding up.
Syntax: ceil(x)
Examples:
->x = 2.1;
y = ceil(x); % Result: y = 3
Here, 2.1 is rounded up to 3.
->x = -1.7;
y = ceil(x); % Result: y = -1
Here, -1.7 is rounded up to -1, as it’s the nearest integer greater than -1.7.
c) The floor Function
Definition: The floor function rounds each element of x to the nearest integer less than or equal to that
element, also known as rounding down.
Syntax: floor(x)
Examples:
->x = 2.9;
y = floor(x); % Result: y = 2
Here, 2.9 is rounded down to 2.
->x = -3.2;
y = floor(x); % Result: y = -4
Here, -3.2 is rounded down to -4, the nearest integer less than -3.2.
Course Code: 20EC0454 R20
3. a. Explain how Trigonometric Functions and Hyperbolic Functionsare handled by MATLAB. Give
some examples.
MATLAB provides a wide range of trigonometric and hyperbolic functions that can operate on real and
complex numbers.
Trigonometric Functions in MATLAB
Trigonometric functions in MATLAB include sine (sin), cosine (cos), tangent (tan), and their inverses
(asin, acos, atan, etc.).
1. Sine Function
Definition: Calculates the sine of an angle (in radians).
Syntax: sin(x)
Example:
x = pi / 2;
y = sin(x); % Result: y = 1
2. Cosine Function
Definition: Calculates the cosine of an angle (in radians).
Syntax: cos(x)
Example:
matlab
Copy code
x = pi;
y = cos(x); % Result: y = -1
3. Tangent Function
Definition: Calculates the tangent of an angle (in radians).
Syntax: tan(x)
Example:
x = pi / 4;
y = tan(x); % Result: y = 1
4. Inverse Trigonometric Functions
These functions return the angle for a given trigonometric ratio.
Syntax: asin(x), acos(x), atan(x)
Example:
Copy code
x = 0.5;
angle_sin = asin(x); % Result: angle_sin ≈ 0.5236 radians (30
degrees)
5. Trignometric Function in Degrees
These functions return the value of given degree for a trigonometric ratio.
Syntax: sind(x),cosd(x),tand(x),asind(x)
Example:
x = 90;
y = sind(x); % Result: y = 1
Hyperbolic Functions in MATLAB
Hyperbolic functions include hyperbolic sine (sinh), hyperbolic cosine (cosh), hyperbolic tangent
(tanh), and their inverses (asinh, acosh, atanh).
1. Hyperbolic Sine Function
Definition: Calculates the hyperbolic sine of a number.
Syntax: sinh(x)
Example:
Course Code: 20EC0454 R20
x = 1;
y = sinh(x); % Result: y ≈ 1.1752
2. Hyperbolic Cosine Function
Definition: Calculates the hyperbolic cosine of a number.
Syntax: cosh(x)
Example:
x = 1;
y = cosh(x); % Result: y ≈ 1.5431
3. Hyperbolic Tangent Function
Definition: Calculates the hyperbolic tangent of a number.
Syntax: tanh(x)
Example:
x = 1;
y = tanh(x); % Result: y ≈ 0.7616
4. Inverse Hyperbolic Functions
These functions return the hyperbolic angle corresponding to a given hyperbolic ratio.
Syntax: asinh(x), acosh(x), atanh(x)
Example:
x = 1;
angle_sinh = asinh(x); % Result: angle_sinh ≈ 0.8814
3 .b Compute the following using MATLAB.
a)For several values of x in the range 0 ≤x ≤ 2, confirm that
tan (2 x) = 2 tan x/ (1-tan2x).
b) For several values of x in the range 0 ≤x ≤5, confirm that sin(ix)= isinhx..
a) Verifying tan(2x)=2tan(x) / 1−tan^2(x) for 0≤ x ≤20 .
This identity can be checked by defining a vector of values for xxx within the range and calculating both
the left-hand side (tan(2*x)) and the right-hand side (2 * tan(x) / (1 - tan(x)^2)).
Matlab code:
% Define x values from 0 to 2 in increments of 0.1
x = 0:0.1:2;
% Define a tolerance for comparison
tolerance = 1e-6;
% Loop through each x value to check the equality
for i = 1:length(x)
% Calculate the left-hand side and right-hand side for each x
lhs = tan(2 * x(i));
rhs = (2 * tan(x(i))) / (1 - tan(x(i))^2);
% Check if they are approximately equal
if abs(lhs - rhs) < tolerance
disp(['x = ', num2str(x(i)), ' : equals']);
else
disp(['x = ', num2str(x(i)), ' : not equals']);
end
end
b) Verifying sin(ix)=isinh(x)\sin(ix) for 0≤ x ≤5 .
In this identity, iii is the imaginary unit, and xxx is a real number. To test this, we can calculate the left-
hand side (sin(i*x)) and the right-hand side (i *sinh(x)) for several values of x between 0 and 5.
Course Code: 20EC0454 R20
Mat lab Code:
% Define x values from 0 to 5 in increments of 0.5
x = 0:0.5:5;
% Define a tolerance for comparison
tolerance = 1e-6;
% Loop through each x value to check the equality
for i = 1:length(x)
% Calculate the left-hand side and right-hand side for each x
lhs = sin(1i * x(i));
rhs = 1i * sinh(x(i));
% Check if they are approximately equal
if abs(lhs - rhs) < tolerance
disp(['x = ', num2str(x(i)), ' : equals']);
else
disp(['x = ', num2str(x(i)), ' : not equals']);
end
end
4. a. What is User-Defined Functions? Give Some Simple Function Examples.
In MATLAB, a user-defined function is a custom function created by the user to perform specific
operations or calculations. Unlike built-in functions, these are saved as separate files with the extension
.m, and can be called by their file name to perform their defined tasks. User-defined functions help
organize code, avoid repetition, and make programs easier to maintain.
Syntax for a User-Defined Function
A user-defined function in MATLAB typically follows this syntax:
function [output1, output2, ...] = functionName(input1, input2, ...)
% Function code here
end
Function : Keyword that defines a new function.
output1, output2, ... : Optional output variables the function returns.
functionName : The name of the function file (must match the filename).
input1, input2, ... : Input arguments the function accepts.
Example 1:
This function calculates the square of a number. Save the function as squareNumber.m.
function result = squareNumber(x)
% Calculates the square of the input number
result = x^2;
end
% Main script
x = 4;
output = squareNumber(x);
disp(output); % Output will be 16
Example 2:
This function takes two numbers and returns their sum. Save this function as addNumbers.m.
function sum = addNumbers(a, b)
% Adds two numbers and returns the result
sum = a + b;
end
% Main script
a = 5;
Course Code: 20EC0454 R20
b = 3;
output = addNumbers(a, b);
disp(output); % Output will be 8
4. b. Write short note on minimizing a function of one variable.
Minimizing a function of one variable involves finding the point at which the function takes its
smallest value over a given interval or domain. This process is common in optimization, where we
seek the minimum of a function f(x) over an interval [a,b]. In MATLAB, this is typically done using
numerical methods like fminbnd.
MATLAB Example Using fminbnd:
The function fminbnd in MATLAB is specifically designed to find the minimum of a single-variable
function over a specified interval.
Syntax:
x_min = fminbnd(@functionName, a, b);
• @functionName : Handle to the function you want to minimize.
• a, b : The interval within which MATLAB will search for the minimum.
Example: Minimizing f(x)=(x−3)^2+5
Define and minimize this function over an interval [0,5].
% Define the function as an anonymous function
f = @(x) (x - 3)^2 + 5;
% Find the minimum over the interval [0, 5]
x_min = fminbnd(f, 0, 5);
% Display the minimum value
disp(['Minimum occurs at x = ', num2str(x_min)]);
disp(['Minimum value is f(x) = ', num2str(f(x_min))]);
Expected Output:
Minimum occurs at x = 3
Minimum value is f(x) = 5
5. a. Compute the area A and circumference C of a circle, given its radius(r=4) as an input
argument.
To calculate the area A and circumference C of a circle given its radius r=4, we can use the following
formulas:
Area: A=πr^2
Circumference : C =2πr
MATLAB Code
Save the following code as circleProperties.m:
function [A, C] = circleProperties(r)
% This function calculates the area and circumference of a circle
% given its radius r.
% Calculate the area
A = pi * r^2;
% Calculate the circumference
C = 2 * pi * r;
end
Main Script :
r = 4;
[A, C] = circleProperties(r);
% Display the results
disp(['Area A = ', num2str(A)]);
disp(['Circumference C = ', num2str(C)]);
Course Code: 20EC0454 R20
Output :
Area A = 50.2655 Circumference C = 25.1327
5 .b. What are the advantages of User-Defined Functions in MATLAB?
User-defined functions in MATLAB provide the following advantages:
1. Reusability : Functions can be used multiple times, saving time and reducing redundancy.
2. Readability : Code is easier to read and follow by breaking it into modular pieces.
3. Simplified Debugging : Functions can be tested individually, simplifying error-finding.
4. Reduced Code Length : Calling functions avoids repetitive code, making scripts shorter.
5. Scalability : Functions make it easy to add or modify features as projects grow.
6. Encapsulation : Functions encapsulate specific tasks, hiding implementation details for better
abstraction.
6. a. Distinguish between Local Variables and Global Variables.
Local Variables
• Definition: Variables that are defined within a function and are only accessible within that
specific function.
• Scope: Limited to the function in which they are defined. They cannot be accessed or modified
outside that function.
• Example:
function myFunction()
x = 10; % Local variable
disp(x);
end
Here, x is a local variable to myFunction and cannot be accessed outside of it.
Global Variables
• Definition: Variables that can be accessed and modified from any function or workspace in
MATLAB, provided they are declared as global in each context they are used.
• Scope: Available across different functions or workspaces where they are explicitly declared as
global.
• Usage: To use a global variable in MATLAB, declare it with the keyword global in each
function or workspace where you want to access it.
• Example:
global y; % Declare global variable in base workspace
y = 20;
function modifyGlobal()
global y; % Declare global in this function too
y = y + 5;
end
modifyGlobal(); % This will change y to 25
disp(y); % Displays 25 in the base workspace
Here, y is a global variable and can be accessed and modified by any function or workspace
where it's declared as global.
6. b. Explain about methods for calling functions.
In MATLAB, there are several ways to call functions, depending on the function type as follows :
1. Calling Built-in MATLAB Functions
MATLAB has a large library of built-in functions, such as sin, cos, mean, sum, and others, which can
be called directly with the required input arguments.
Example :
result = mean([1, 2, 3, 4, 5]);
Course Code: 20EC0454 R20
Here, mean is a built-in function, and you call it by passing in an array as an argument.
2. Calling User-Defined Functions
Functions created by the user can be saved as separate .m files and then called in the script or command
window. Each .m file should be named after the function it defines.
% Example: File "myFunction.m"
function output = myFunction(input)
output = input^2;
end
% Calling the function
result = myFunction(5); % Output will be 25
3. Calling Nested Functions
A nested function is defined within another function, and it has access to the variables of the outer
function. Nested functions are helpful for tasks that require helper functions.
Example :
function mainFunction()
x = 10;
disp(nestedFunction(x));

function y = nestedFunction(x)
y = x^2;
end
end
Here, nestedFunction can only be called within mainFunction.
4. Calling Subfunctions
Subfunctions are additional functions defined within the same .m file as the main function but outside of
its main body. Subfunctions can only be called by the main function or other subfunctions within the
same file.
% Example: File "mainFunction.m"
function result = mainFunction()
result = helperFunction(5);
end

function output = helperFunction(input)

output = input^2;
end
Here, helperFunction is a subfunction and can be called by mainFunction.
5. Calling Anonymous Functions
Anonymous functions are functions that are defined in a single line using the @ symbol. They are often
used for short, simple operations and can be called directly or passed as arguments.
Example :
square = @(x) x^2;
result = square(5); % Output will be 25
7. What is mean by functions? Explain various types functions in MATLAB with suitable
example.
Function :
In MATLAB, functions are self-contained blocks of code designed to perform specific tasks. They take
inputs, process them, and return outputs. Functions help in organizing code, improving readability, and
reusability. MATLAB has several types of functions, including built-in functions, user-defined functions,
anonymous functions, nested functions, variable argument lists, private functions, and subfunctions.
Course Code: 20EC0454 R20
Types of Functions in MATLAB
1. Built-in Functions
These are predefined functions provided by MATLAB for various mathematical and engineering
operations.
Syntax:
output = builtInFunction(input)
Example:
% Using the built-in function 'sqrt' to calculate the square root of a
number
result = sqrt(16);
disp(result); % Output: 4
2. User-defined Functions
User-defined functions are created by the user to perform specific tasks. They can take input arguments
and return output values.
Syntax:
function output = functionName(input1, input2, ...)
% Function body
end
Example:
% Define a user-defined function 'addNumbers' in a file named
'addNumbers.m'
function result = addNumbers(a, b)
result = a + b; % Add two numbers
end
% Call the user-defined function
sum = addNumbers(5, 10);
disp(sum); % Output: 15
3. Anonymous Functions
Anonymous functions are one-line functions defined without a separate file. They are useful for simple
operations and can be created using the @ symbol.
Syntax:
f = @(input) expression
Example:
% Define an anonymous function that squares a number
square = @(x) x^2;

% Call the anonymous function

result = square(4);
disp(result); % Output: 16
4. Nested Functions
Nested functions are defined within another function. They can access variables from the parent
function's workspace.
Syntax:
function output = outerFunction(input)
% Nested function
function innerOutput = innerFunction(innerInput)
% Access outer function variables
end
output = innerFunction(input);
Course Code: 20EC0454 R20
end
Example:
% Define a function 'outerFunction' with a nested function
'innerFunction'
function outerFunction()
a = 5; % Variable in the outer function
% Define the nested function
function b = innerFunction()
b = a + 10; % Accessing variable 'a' from the outer function
end
result = innerFunction(); % Call the nested function
disp(result); % Output: 15
end
% Call the outer function
outerFunction();
5. Private Functions
Private functions are defined in a separate file and are only accessible to functions in the same directory
or in subdirectories. They are useful for encapsulating functionality that should not be exposed to users of
your primary function or module.
Syntax:
% In 'myFunction.m'
function output = myFunction(x)
output = privateFunction(x); % Call the private function
end
Example of Private Function:
1. Create a folder named myFunctions.
2. Create a file named myFunction.m inside the folder:
function output = myFunction(x)
% Call the private function
output = privateFunction(x);
end
3. Create another file named privateFunction.m inside the myFunctions/private
directory:
function result = privateFunction(y)
% This function is private to 'myFunction'
result = y^2; % Square the input
end
4. Call the function from the command window:
% Set the current folder to 'myFunctions'
result = myFunction(5);
disp(result); % Output: 25
6. Subfunctions
Subfunctions are functions defined within the same file as another function. They can only be called by
the main function in that file or other subfunctions defined in the same file. Subfunctions are useful for
organizing code related to a primary function without making them accessible outside of that context.
Syntax:
function output = mainFunction(input)
% Call the subfunction
end
Course Code: 20EC0454 R20
function output = subFunction(input)
% This is a subfunction
end
Example of Subfunction:
1. Create a file named mainFunction.m:
function result = mainFunction(x)
% Call the subfunction
result = squareValue(x);
end

function result = squareValue(y)

% This is a subfunction
result = y^2; % Square the input
end
2. Call the function from the command window:
result = mainFunction(4);
disp(result); % Output: 16
8. a. Explain about Anonymous Functions with suitable example.
Anonymous Functions
Anonymous functions are one-line functions defined without a separate file. They are useful for simple
operations and can be created using the @ symbol.
Syntax:
f = @(input) expression
Example:
% Define an anonymous function that squares a number
square = @(x) x^2;
% Call the anonymous function
result = square(4);
disp(result); % Output: 16
8. b. How Multiple-Input Arguments are handled in Anonymous Functions
In MATLAB, anonymous functions can handle multiple input arguments using the same syntax as regular
functions. The key is to define the function using a single variable for all inputs and then use that variable
as needed within the function body. Here's how it works:
Syntax for Multiple-Input Arguments
To create an anonymous function that accepts multiple input arguments, use the following syntax:
f = @(input1, input2, ...) expression
Example: Using Multiple Input Arguments in an Anonymous Function
create an anonymous function that takes two inputs and performs a mathematical operation.
Example 1: Sum of Two Numbers
% Define an anonymous function that takes two inputs and returns their
sum
sumFunction = @(x, y) x + y;
% Call the anonymous function
result = sumFunction(5, 3);
disp(result); % Output: 8
Example 2: Using Array Inputs
Anonymous functions can also handle array inputs. In this case, the function operates element-wise on
arrays.
% Define an anonymous function that multiplies two arrays element-wise
Course Code: 20EC0454 R20
elementWiseMultiplication = @(x, y) x .* y;
% Call the anonymous function with arrays
result = elementWiseMultiplication([1, 2, 3], [4, 5, 6]);
disp(result); % Output: [4 10 18]
9.a. What are Nested Functions? Explain with suitable example.
Nested Functions
Nested functions are defined within another function. They can access variables from the parent
function's workspace.
Syntax:
function output = outerFunction(input)
% Nested function
function innerOutput = innerFunction(innerInput)
% Access outer function variables
end
output = innerFunction(input);
end
Example:
% Define a function 'outerFunction' with a nested function
'innerFunction'
function outerFunction()
a = 5; % Variable in the outer function
% Define the nested function
function b = innerFunction()
b = a + 10; % Accessing variable 'a' from the outer function
end
result = innerFunction(); % Call the nested function
disp(result); % Output: 15
end
% Call the outer function
outerFunction();
9. b. Explain about Private function with suitable example.
Private Functions :
Private functions are defined in a separate file and are only accessible to functions in the same
directory or in subdirectories. They are useful for encapsulating functionality that should not be
exposed to users of your primary function or module.
Syntax:
% In 'myFunction.m'
function output = myFunction(x)
output = privateFunction(x); % Call the private function
end
Example of Private Function:
Create a folder named myFunctions.
Create a file named myFunction.m inside the folder:
function output = myFunction(x)
% Call the private function
output = privateFunction(x);
end
Create another file named privateFunction.m inside the myFunctions/private
directory:
Course Code: 20EC0454 R20
function result = privateFunction(y)
% This function is private to 'myFunction'
result = y^2; % Square the input
end
Call the function from the command window:
% Set the current folder to 'myFunctions'
result = myFunction(5);
disp(result); % Output: 25
.
10.a. Briefly explain importing wizard and excel data files in MATLAB.
In MATLAB, importing data from Excel files or using the Import Wizard is by the following methods:
1. Importing Wizard:
• Accessing the Wizard: You can start the Import Wizard by selecting Import Data from the
Home tab in the MATLAB toolstrip or by using the uiimport command in the command
window.
• File Selection: The wizard allows you to browse for a file (e.g., .csv, .txt, .xls).
• Data Preview: Once a file is selected, you can see a preview of the data, where you can choose
which variables to import and how to format them.
• Options: You can set options such as specifying delimiters, selecting variable names, and
handling missing data.
• Importing: After configuring the settings, you can import the data into the MATLAB workspace
as a table or array.
2. Importing Excel Data Files:
• Using readtable or readmatrix: You can directly import Excel files using these functions.
For example:
o data = readtable('filename.xlsx'); imports data as a table.
o data = readmatrix('filename.xlsx'); imports data as a numeric matrix.
• Specifying Sheets and Range: You can specify the sheet name and range within the file:
data = readtable('filename.xlsx', 'Sheet', 'Sheet1', 'Range',
'A1:D10');
• Handling Different Data Types: MATLAB automatically detects and converts different data
types in the Excel file, making it easy to work with mixed data.
10.b. How to Export ASCII Data Files in MATLAB?
Exporting ASCII data files in MATLAB can be done using several functions, depending on specific
needs and the format we want by the following ways:
1. Using writematrix
For exporting numeric matrices, writematrix is a straightforward option:
data = rand(5); % Example data (5x5 matrix)
writematrix(data, 'output.txt'); % Exports to a text file
2. Using writetable
If you are working with tables, writetable is ideal:
T = table((1:5)', rand(5,1), 'VariableNames', {'Index', 'Value'});
writetable(T, 'output.txt'); % Exports to a text file
3. Using dlmwrite (for older versions)
For versions of MATLAB prior to R2019a, you can use dlmwrite:
data = rand(5); % Example data
dlmwrite('output.txt', data, 'delimiter', '\t'); % Exports with tab
delimiter
Course Code: 20EC0454 R20
4. Using fprintf
For more control over the formatting, fprintf can be used:
data = rand(5); % Example data
fileID = fopen('output.txt', 'w'); % Open file for writing
fprintf(fileID, '%f %f\n', data'); % Write data to file (transposed)
fclose(fileID); % Close the file