x = 3
isinteger(x)
isfloat(x)
isvector(x)
isscalar(x)
isnumeric(x)
 
x = 23.54
isinteger(x)
isfloat(x)
isvector(x)
isscalar(x)
isnumeric(x)
 
x = [1 2 3]
isinteger(x)
isfloat(x)
isvector(x)
isscalar(x)
 
x = 'Hello'
isinteger(x)
isfloat(x)
isvector(x)
isscalar(x)
isnumeric(x)

Когда вы запускаете файл, он дает следующий результат —

x = 3
ans = 0
ans = 1
ans = 1
ans = 1
ans = 1
x = 23.540
ans = 0
ans = 1
ans = 1
ans = 1
ans = 1
x =

          1          2          3

ans = 0
ans = 1
ans = 1
ans = 0
x = Hello
ans = 0
ans = 0
ans = 1
ans = 0
ans = 0

MATLAB — Операторы

Оператор — это символ, который указывает компилятору выполнять определенные математические или логические манипуляции. MATLAB предназначен для работы преимущественно с целыми матрицами и массивами. Следовательно, операторы в MATLAB работают как со скалярными, так и нескалярными данными. MATLAB допускает следующие виды элементарных операций —

• Арифметические Операторы
• Операторы отношений
• Логические Операторы
• Побитовые операции
• Операции над множествами

Арифметические Операторы

MATLAB допускает два различных типа арифметических операций —

• Матричные арифметические операции
• Массив арифметических операций

Матричные арифметические операции аналогичны определенным в линейной алгебре. Операции с массивами выполняются поэлементно, как в одномерном, так и в многомерном массиве.

Матричные операторы и операторы массива дифференцируются символом точки (.). Однако, поскольку операция сложения и вычитания одинакова для матриц и массивов, оператор одинаков для обоих случаев. Следующая таблица дает краткое описание операторов —

Показать примеры

+

Дополнение или унарный плюс. A + B добавляет значения, хранящиеся в переменных A и B. A и B должны иметь одинаковый размер, если только один не является скаляром. Скаляр можно добавить в матрицу любого размера.

—

Вычитание или унарный минус. AB вычитает значение B из A. A и B должны иметь одинаковый размер, если только он не является скаляром. Скаляр можно вычесть из матрицы любого размера.

*

Матричное умножение. C = A * B — линейное алгебраическое произведение матриц A и B. Точнее,

Для нескалярных A и B число столбцов в A должно быть равно количеству строк в B. Скаляр может умножить матрицу любого размера.

. *

Умножение массивов. A. * B — это поэлементное произведение массивов A и B. A и B должны иметь одинаковый размер, если только один из них не является скаляром.

/

Косая черта или матрица правого деления. B / A примерно такой же, как B * inv (A). Точнее, B / A = (A ‘\ B’) ‘.

./

Массив правого деления. A./B — матрица с элементами A (i, j) / B (i, j). A и B должны иметь одинаковый размер, если только один из них не является скаляром.

\

Обратная косая черта или матрица левого деления. Если A — квадратная матрица, A \ B — примерно то же самое, что inv (A) * B, за исключением того, что она вычисляется другим способом. Если A является матрицей n-на-n и B является вектором столбцов с n компонентами, или матрицей с несколькими такими столбцами, то X = A \ B является решением уравнения AX = B. Предупреждающее сообщение отображается, если А плохо масштабировано или почти единственное число.

. \

Массив покинул деление. A. \ B — матрица с элементами B (i, j) / A (i, j). A и B должны иметь одинаковый размер, если только один из них не является скаляром.

^

Матрица власти. X ^ p есть X в степени p, если p скаляр. Если p является целым числом, мощность вычисляется путем повторного возведения в квадрат. Если целое число отрицательно, X инвертируется первым. Для других значений p в расчет включаются собственные значения и собственные векторы, например, если [V, D] = eig (X), то X ^ p = V * D. ^ p / V.

. ^

Массив власти. A. ^ B — это матрица с элементами A (i, j) степени B (i, j). A и B должны иметь одинаковый размер, если только один из них не является скаляром.

‘

Матрица транспонировать. A ‘- линейная алгебраическая транспонирование A. Для комплексных матриц это комплексная сопряженная транспонирование.

«.

Массив транспонировать. A.» это транспонирование массива A. Для сложных матриц это не связано с сопряжением.

Операторы отношений

Реляционные операторы также могут работать как со скалярными, так и с нескалярными данными. Реляционные операторы для массивов выполняют поэлементное сравнение двух массивов и возвращают логический массив одинакового размера с элементами, установленными в логическое 1 (истина), где отношение истинно, и элементами, установленными в логическое 0 (ложь), где оно не.

В следующей таблице показаны реляционные операторы, доступные в MATLAB.

Показать примеры

<

Меньше, чем

<=

Меньше или равно

>

Лучше чем

> =

Больше или равно

==

Равно

~ =

Не равно

Логические Операторы

MATLAB предлагает два типа логических операторов и функций —

• Поэлементный — Эти операторы работают с соответствующими элементами логических массивов.

• Короткое замыкание — эти операторы работают со скалярными и логическими выражениями.

Поэлементный — Эти операторы работают с соответствующими элементами логических массивов.

Короткое замыкание — эти операторы работают со скалярными и логическими выражениями.

Поэлементные логические операторы работают поэлементно на логических массивах. Символы &, | и ~ являются операторами логических массивов И, ИЛИ и НЕ.

Логические операторы короткого замыкания допускают короткое замыкание на логических операциях. Символы && и || являются логическими операторами короткого замыкания И и ИЛИ.

Показать примеры

Побитовые операции

Битовые операторы работают с битами и выполняют побитовые операции. Таблицы истинности для &, | и ^ следующие:

Предположим, если А = 60; и B = 13; Теперь в двоичном формате они будут выглядеть следующим образом —

A = 0011 1100

B = 0000 1101

——————

A & B = 0000 1100

A | B = 0011 1101

A ^ B = 0011 0001

~ A = 1100 0011

MATLAB предоставляет различные функции для побитовых операций, таких как «побитовое и», «побитовое или» и «побитовое не», операция сдвига и т. Д.

В следующей таблице приведены часто используемые побитовые операции —

Показать примеры

Операции над множествами

MATLAB предоставляет различные функции для операций над множествами, такие как объединение, пересечение и тестирование для множества множеств и т. Д.

В следующей таблице приведены некоторые часто используемые операции над множествами:

Показать примеры

пересекаются (А, В)

Установить пересечение двух массивов; возвращает значения, общие для A и B. Возвращаемые значения находятся в отсортированном порядке.

пересекаются (A, B, ‘строки’)

Обрабатывает каждую строку A и каждую строку B как отдельные объекты и возвращает строки, общие как для A, так и для B. Строки возвращенной матрицы расположены в отсортированном порядке.

IsMember (А, В)

Возвращает массив того же размера, что и A, содержащий 1 (true), где элементы A находятся в B. В других местах он возвращает 0 (false).

IsMember (A, B, ‘строк’)

Обрабатывает каждую строку A и каждую строку B как отдельные объекты и возвращает вектор, содержащий 1 (true), где строки матрицы A также являются строками B. В другом месте возвращается 0 (false).

issorted (А)

Возвращает логическое 1 (истина), если элементы A расположены в отсортированном порядке, и логическое 0 (ложь) в противном случае. Вход A может быть вектором или массивом строк размером 1 на 1 или 1 на N. A считается отсортированным, если A и выходные данные сортировки (A) равны.

issorted (A, ‘row’)

Возвращает логическое 1 (истина), если строки двумерной матрицы A расположены в отсортированном порядке, и логическое 0 (ложь) в противном случае. Матрица A считается отсортированной, если A и выходные данные sortrows (A) равны.

setdiff (А, В)

Устанавливает разницу двух массивов; возвращает значения в A, которых нет в B. Значения в возвращенном массиве расположены в отсортированном порядке.

setdiff (А, В, ‘строк’)

Обрабатывает каждую строку A и каждую строку B как отдельные объекты и возвращает строки из A, которых нет в B. Строки возвращенной матрицы расположены в отсортированном порядке.

Опция ‘rows’ не поддерживает массивы ячеек.

setxor

Устанавливает эксклюзивное ИЛИ из двух массивов

союз

Устанавливает объединение двух массивов

уникальный

Уникальные значения в массиве

MATLAB — принятие решений

Структуры принятия решений требуют, чтобы программист указал одно или несколько условий, которые должны быть оценены или протестированы программой, вместе с оператором или инструкциями, которые должны быть выполнены, если условие определено как истинное, и, необязательно, другие операторы, которые должны быть выполнены, если условие определяется как ложное.

Ниже приводится общая форма типичной структуры принятия решений, встречающейся в большинстве языков программирования.

MATLAB предоставляет следующие типы заявлений о принятии решений. Нажмите на следующие ссылки, чтобы проверить их детали —

Оператор if … end состоит из логического выражения, за которым следует один или несколько операторов.

За оператором if может следовать необязательный оператор else , который выполняется, когда логическое выражение имеет значение false.

За оператором if может следовать один (или несколько) необязательных elseif … и оператор else , что очень полезно для проверки различных условий.

Вы можете использовать один оператор if или elseif внутри другого оператора if или elseif .

Оператор switch позволяет проверять переменную на соответствие списку значений.

Вы можете использовать один оператор switch внутри другого оператора (ов) switch .

MATLAB — Типы петель

Может возникнуть ситуация, когда вам нужно выполнить блок кода несколько раз. Как правило, операторы выполняются последовательно. Первый оператор в функции выполняется первым, затем следует второй и так далее.

Языки программирования предоставляют различные управляющие структуры, которые допускают более сложные пути выполнения.

Оператор цикла позволяет нам выполнять оператор или группу операторов несколько раз, и в большинстве языков программирования ниже приводится общая форма инструкции цикла.

MATLAB предоставляет следующие типы циклов для обработки требований циклов. Нажмите на следующие ссылки, чтобы проверить их детали —

Повторяет оператор или группу операторов, пока данное условие выполняется. Он проверяет условие перед выполнением тела цикла.

Выполняет последовательность операторов несколько раз и сокращает код, который управляет переменной цикла.

Вы можете использовать один или несколько циклов внутри любого другого цикла.

Заявления о контроле цикла

Операторы управления циклом изменяют выполнение от его нормальной последовательности. Когда выполнение покидает область действия, все автоматические объекты, созданные в этой области, уничтожаются.

MATLAB поддерживает следующие управляющие операторы. Нажмите на следующие ссылки, чтобы проверить их детали.

Завершает оператор цикла и передает выполнение в оператор, следующий сразу за циклом.

Заставляет петлю пропускать оставшуюся часть своего тела и немедленно проверять свое состояние перед повторением.

MATLAB — Векторы

Вектор — это одномерный массив чисел. MATLAB позволяет создавать два типа векторов —

• Векторы строк
• Векторы столбцов

Строки Векторы

Векторы строк создаются путем заключения набора элементов в квадратных скобках с использованием пробела или запятой для разделения элементов.

Live Demo

r = [7 8 9 10 11]

r =

   7    8    9   10   11 

c = [7;  8;  9;  10; 11]

c =
      7       
      8       
      9       
      10       
      11  
 

v = [ 1; 2; 3; 4; 5; 6];	% creating a column vector of 6 elements
v(3)

ans =  3

v = [ 1; 2; 3; 4; 5; 6];	% creating a column vector of 6 elements
v(:)

ans =
     1
     2
     3
     4
     5
     6

rv = [1 2 3 4 5 6 7 8 9];
sub_rv = rv(3:7)

sub_rv =

   3   4   5   6   7

a = [ 1 2 3 4 5; 2 3 4 5 6; 3 4 5 6 7; 4 5 6 7 8]

a =
      1     2     3     4     5
      2     3     4     5     6
      3     4     5     6     7
      4     5     6     7     8

mx(m, n);

a = [ 1 2 3 4 5; 2 3 4 5 6; 3 4 5 6 7; 4 5 6 7 8];
a(2,5)

ans =  6

a = [ 1 2 3 4 5; 2 3 4 5 6; 3 4 5 6 7; 4 5 6 7 8];
v = a(:,4)

v =
      4
      5
      6
      7

a(:,m:n)

a = [ 1 2 3 4 5; 2 3 4 5 6; 3 4 5 6 7; 4 5 6 7 8];
a(:, 2:3)

ans =
      2     3
      3     4
      4     5
      5     6

a = [ 1 2 3 4 5; 2 3 4 5 6; 3 4 5 6 7; 4 5 6 7 8];
a(:, 2:3)

ans =
      2     3
      3     4
      4     5
      5     6

3     4     5     
4     5     6     

a = [ 1 2 3 4 5; 2 3 4 5 6; 3 4 5 6 7; 4 5 6 7 8];
sa = a(2:3,2:4)

sa =
      3     4     5
      4     5     6

a = [ 1 2 3 4 5; 2 3 4 5 6; 3 4 5 6 7; 4 5 6 7 8];
a( 4 , : ) = []

a =
      1     2     3     4     5
      2     3     4     5     6
      3     4     5     6     7

a = [ 1 2 3 4 5; 2 3 4 5 6; 3 4 5 6 7; 4 5 6 7 8];
a(: , 5)=[]

a =
      1     2     3     4
      2     3     4     5
      3     4     5     6
      4     5     6     7

a = [ 1 2 3 ; 4 5 6; 7 8 9];
new_mat = a([2,3,2,3],:)

new_mat =
      4     5     6
      7     8     9
      4     5     6
      7     8     9

zeros(5)

ans =
      0     0     0     0     0
      0     0     0     0     0
      0     0     0     0     0
      0     0     0     0     0
      0     0     0     0     0

ones(4,3)

ans =
      1     1     1
      1     1     1
      1     1     1
      1     1     1

eye(4)

ans =
      1     0     0     0
      0     1     0     0
      0     0     1     0
      0     0     0     1

rand(3, 5)

ans =
   0.8147    0.9134    0.2785    0.9649    0.9572
   0.9058    0.6324    0.5469    0.1576    0.4854
   0.1270    0.0975    0.9575    0.9706    0.8003

magic(4)

ans =
   16     2     3    13
   5    11    10     8
   9     7     6    12
   4    14    15     1

a = [7 9 5; 6 1 9; 4 3 2]

a =
   7     9     5
   6     1     9
   4     3     2

a(:, :, 2)= [ 1 2 3; 4 5 6; 7 8 9]

a =

ans(:,:,1) =

   0   0   0
   0   0   0
   0   0   0

ans(:,:,2) =

   1   2   3
   4   5   6
   7   8   9

b = rand(4,3,2)

b(:,:,1) =
   0.0344    0.7952    0.6463
   0.4387    0.1869    0.7094
   0.3816    0.4898    0.7547
   0.7655    0.4456    0.2760

b(:,:,2) =
   0.6797    0.4984    0.2238
   0.6551    0.9597    0.7513
   0.1626    0.3404    0.2551
   0.1190    0.5853    0.5060

B = cat(dim, A1, A2...)

a = [9 8 7; 6 5 4; 3 2 1];
b = [1 2 3; 4 5 6; 7 8 9];
c = cat(3, a, b, [ 2 3 1; 4 7 8; 3 9 0])

c(:,:,1) =
      9     8     7
      6     5     4
      3     2     1
c(:,:,2) =
      1     2     3
      4     5     6
      7     8     9
c(:,:,3) =
      2     3     1
      4     7     8
      3     9     0

x = [7.1, 3.4, 7.2, 28/4, 3.6, 17, 9.4, 8.9];
length(x)      % length of x vector
y = rand(3, 4, 5, 2);
ndims(y)       % no of dimensions in array y
s = ['Zara', 'Nuha', 'Shamim', 'Riz', 'Shadab'];
numel(s)       % no of elements in s

ans =  8
ans =  4
ans =  23

a = [1 2 3; 4 5 6; 7 8 9]  % the original array a
b = circshift(a,1)         %  circular shift first dimension values down by 1.
c = circshift(a,[1 -1])    % circular shift first dimension values % down by 1 
                           % and second dimension values to the left % by 1.

a =
   1     2     3
   4     5     6
   7     8     9

b =
   7     8     9
   1     2     3
   4     5     6

c =
   8     9     7
   2     3     1
   5     6     4

v = [ 23 45 12 9 5 0 19 17]  % horizontal vector
sort(v)                      % sorting v
m = [2 6 4; 5 3 9; 2 0 1]    % two dimensional array
sort(m, 1)                   % sorting m along the row
sort(m, 2)                   % sorting m along the column

v =
   23    45    12     9     5     0    19    17
ans =
   0     5     9    12    17    19    23    45
m =
   2     6     4
   5     3     9
   2     0     1
ans =
   2     0     1
   2     3     4
   5     6     9
ans =
   2     4     6
   3     5     9
   0     1     2

C = cell(dim)
C = cell(dim1,...,dimN)
D = cell(obj)

c = cell(2, 5);
c = {'Red', 'Blue', 'Green', 'Yellow', 'White'; 1 2 3 4 5}

c = 
{
   [1,1] = Red
   [2,1] =  1
   [1,2] = Blue
   [2,2] =  2
   [1,3] = Green
   [2,3] =  3
   [1,4] = Yellow
   [2,4] =  4
   [1,5] = White
   [2,5] =  5
}

c = {'Red', 'Blue', 'Green', 'Yellow', 'White'; 1 2 3 4 5};
c(1:2,1:2)

ans = 
{
   [1,1] = Red
   [2,1] =  1
   [1,2] = Blue
   [2,2] =  2
}

c = {'Red', 'Blue', 'Green', 'Yellow', 'White'; 1 2 3 4 5};
c{1, 2:4}

ans = Blue
ans = Green
ans = Yellow

1:10

ans =                                                                           
                                                                                
   1    2    3    4    5    6    7    8    9   10 

100: -5: 50

ans =
   100    95    90    85    80    75    70    65    60    55    50

0:pi/8:pi

ans =
   Columns 1 through 7
      0    0.3927    0.7854    1.1781    1.5708    1.9635    2.3562
   Columns 8 through 9
      2.7489    3.1416

A = [1 2 3 4; 4 5 6 7; 7 8 9 10]
A(:,2)      % second column of A
A(:,2:3)    % second and third column of A
A(2:3,2:3)  % second and third rows and second and third columns

A =
      1     2     3     4
      4     5     6     7
      7     8     9    10

ans =
      2
      5
      8

ans =
      2     3
      5     6
      8     9

ans =
      5     6
      8     9

x = single([5.32 3.47 6.28]) .* 7.5
x = double([5.32 3.47 6.28]) .* 7.5
x = int8([5.32 3.47 6.28]) .* 7.5
x = int16([5.32 3.47 6.28]) .* 7.5
x = int32([5.32 3.47 6.28]) .* 7.5
x = int64([5.32 3.47 6.28]) .* 7.5

x =

   39.900   26.025   47.100

x =

   39.900   26.025   47.100

x =

   38  23  45

x =

   38  23  45

x =

   38  23  45

x =

   38  23  45

x = int32([5.32 3.47 6.28]) .* 7.5
x = int64([5.32 3.47 6.28]) .* 7.5
x = num2cell(x)

x =

   38  23  45

x =

   38  23  45

x = 
{
   [1,1] = 38
   [1,2] = 23
   [1,3] = 45
}

% displaying the smallest and largest signed integer data
str = 'The range for int8 is:\n\t%d to %d ';
sprintf(str, intmin('int8'), intmax('int8'))
str = 'The range for int16 is:\n\t%d to %d ';
sprintf(str, intmin('int16'), intmax('int16'))
str = 'The range for int32 is:\n\t%d to %d ';
sprintf(str, intmin('int32'), intmax('int32'))
str = 'The range for int64 is:\n\t%d to %d ';
sprintf(str, intmin('int64'), intmax('int64'))
 
% displaying the smallest and largest unsigned integer data
str = 'The range for uint8 is:\n\t%d to %d ';
sprintf(str, intmin('uint8'), intmax('uint8'))
str = 'The range for uint16 is:\n\t%d to %d ';
sprintf(str, intmin('uint16'), intmax('uint16'))
str = 'The range for uint32 is:\n\t%d to %d ';
sprintf(str, intmin('uint32'), intmax('uint32'))
str = 'The range for uint64 is:\n\t%d to %d ';
sprintf(str, intmin('uint64'), intmax('uint64'))

ans = The range for int8 is:
	-128 to 127 
ans = The range for int16 is:
	-32768 to 32767 
ans = The range for int32 is:
	-2147483648 to 2147483647 
ans = The range for int64 is:
	0 to 0 
ans = The range for uint8 is:
	0 to 255 
ans = The range for uint16 is:
	0 to 65535 
ans = The range for uint32 is:
	0 to -1 
ans = The range for uint64 is:
	0 to 18446744073709551616 

% displaying the smallest and largest single-precision 
% floating point number
str = 'The range for single is:\n\t%g to %g and\n\t %g to  %g';
sprintf(str, -realmax('single'), -realmin('single'), ...
   realmin('single'), realmax('single'))

% displaying the smallest and largest double-precision 
% floating point number
str = 'The range for double is:\n\t%g to %g and\n\t %g to  %g';
sprintf(str, -realmax('double'), -realmin('double'), ...
   realmin('double'), realmax('double'))

ans = The range for single is:                                                  
        -3.40282e+38 to -1.17549e-38 and                                        
         1.17549e-38 to  3.40282e+38                                            
ans = The range for double is:                                                  
        -1.79769e+308 to -2.22507e-308 and                                      
         2.22507e-308 to  1.79769e+308

my_string = 'Tutorials Point'

my_string = Tutorials Point

whos

Name           Size            Bytes  Class    Attributes
my_string      1x16               32  char

my_string = 'Tutorial''s Point';
str_ascii = uint8(my_string)        % 8-bit ascii values
str_back_to_char= char(str_ascii)  
str_16bit = uint16(my_string)       % 16-bit ascii values
str_back_to_char = char(str_16bit)  

str_ascii =

   84  117  116  111  114  105   97  108   39  115   32   80  111  105  110  116

str_back_to_char = Tutorial's Point
str_16bit =

   84  117  116  111  114  105   97  108   39  115   32   80  111  105  110  116

str_back_to_char = Tutorial's Point

doc_profile = ['Zara Ali                             '; ...
               'Sr. Surgeon                          '; ...
               'R N Tagore Cardiology Research Center']
doc_profile = char('Zara Ali', 'Sr. Surgeon', ...
                  'RN Tagore Cardiology Research Center')

doc_profile =
Zara Ali                             
Sr. Surgeon                          
R N Tagore Cardiology Research Center
doc_profile =
Zara Ali                            
Sr. Surgeon                         
RN Tagore Cardiology Research Center

name =     'Zara Ali                             ';
position = 'Sr. Surgeon                          '; 
worksAt =  'R N Tagore Cardiology Research Center';
profile = [name ', ' position ', ' worksAt]
profile = strcat(name, ', ', position, ', ', worksAt)

profile = Zara Ali      , Sr. Surgeon      , R N Tagore Cardiology Research Center
profile = Zara Ali,Sr. Surgeon,R N Tagore Cardiology Research Center

name =     'Zara Ali                             ';
position = 'Sr. Surgeon                          '; 
worksAt =  'R N Tagore Cardiology Research Center';
profile = char(name, position, worksAt);
profile = cellstr(profile);
disp(profile)

{                                                                               
   [1,1] = Zara Ali                                                              
   [2,1] = Sr. Surgeon                                                           
   [3,1] = R N Tagore Cardiology Research Center                                 
}   

A = pi*1000*ones(1,5);
sprintf(' %f \n %.2f \n %+.2f \n %12.2f \n %012.2f \n', A)

ans =  3141.592654 
   3141.59 
   +3141.59 
      3141.59 
   000003141.59 

%cell array of strings
str_array = {'red','blue','green', 'yellow', 'orange'};

% Join strings in cell array into single string
str1 = strjoin(str_array, "-")
str2 = strjoin(str_array, ",")

str1 = red-blue-green-yellow-orange
str2 = red,blue,green,yellow,orange

students = {'Zara Ali', 'Neha Bhatnagar', ...
            'Monica Malik', 'Madhu Gautam', ...
            'Madhu Sharma', 'Bhawna Sharma',...
            'Nuha Ali', 'Reva Dutta', ...
            'Sunaina Ali', 'Sofia Kabir'};
 
% The strrep function searches and replaces sub-string.
new_student = strrep(students(8), 'Reva', 'Poulomi')
% Display first names
first_names = strtok(students)

new_student = 
{
   [1,1] = Poulomi Dutta
}
first_names = 
{
   [1,1] = Zara
   [1,2] = Neha
   [1,3] = Monica
   [1,4] = Madhu
   [1,5] = Madhu
   [1,6] = Bhawna
   [1,7] = Nuha
   [1,8] = Reva
   [1,9] = Sunaina
   [1,10] = Sofia
}

str1 = 'This is test'
str2 = 'This is text'
if (strcmp(str1, str2))
   sprintf('%s and %s are equal', str1, str2)
else
   sprintf('%s and %s are not equal', str1, str2)
end

str1 = This is test
str2 = This is text
ans = This is test and This is text are not equal

function [out1,out2, ..., outN] = myfun(in1,in2,in3, ..., inN)

function max = mymax(n1, n2, n3, n4, n5)

%This function calculates the maximum of the
% five numbers given as input
max =  n1;
if(n2 > max)
   max = n2;
end
if(n3 > max)
   max = n3;
end
if(n4 > max)
   max = n4;
end
if(n5 > max)
   max = n5;
end

help mymax

This function calculates the maximum of the
   five numbers given as input

mymax(34, 78, 89, 23, 11)

ans = 89

f = @(arglist)expression

power = @(x, n) x.^n;
result1 = power(7, 3)
result2 = power(49, 0.5)
result3 = power(10, -10)
result4 = power (4.5, 1.5)

result1 =  343
result2 =  7
result3 =  1.0000e-10
result4 =  9.5459

function [x1,x2] = quadratic(a,b,c)

%this function returns the roots of 
% a quadratic equation.
% It takes 3 input arguments
% which are the co-efficients of x2, x and the 
%constant term
% It returns the roots
d = disc(a,b,c); 
x1 = (-b + d) / (2*a);
x2 = (-b - d) / (2*a);
end   % end of quadratic

function dis = disc(a,b,c) 
%function calculates the discriminant
dis = sqrt(b^2 - 4*a*c);
end   % end of sub-function

quadratic(2,4,-4)

ans = 0.7321

function x = A(p1, p2)
...
B(p2)
   function y = B(p3)
   ...
   end
...
end

function [x1,x2] = quadratic2(a,b,c)
function disc  % nested function
d = sqrt(b^2 - 4*a*c);
end   % end of function disc

disc;
x1 = (-b + d) / (2*a);
x2 = (-b - d) / (2*a);
end   % end of function quadratic2

quadratic2(2,4,-4)

ans =  0.73205

function dis = disc(a,b,c) 
%function calculates the discriminant
dis = sqrt(b^2 - 4*a*c);
end      % end of sub-function

function [x1,x2] = quadratic3(a,b,c)

%this function returns the roots of 
% a quadratic equation.
% It takes 3 input arguments
% which are the co-efficient of x2, x and the 
%constant term
% It returns the roots
d = disc(a,b,c); 

x1 = (-b + d) / (2*a);
x2 = (-b - d) / (2*a);
end      % end of quadratic3

quadratic3(2,4,-4)

ans =  0.73205

function avg = average(nums)
global TOTAL
avg = sum(nums)/TOTAL;
end

global TOTAL;
TOTAL = 10;
n = [34, 45, 25, 45, 33, 19, 40, 34, 38, 42];
av = average(n)

av =  35.500

filename = 'smile.jpg';
A = importdata(filename);
image(A);

SunDay  MonDay  TuesDay  WednesDay  ThursDay  FriDay  SaturDay
95.01   76.21   61.54    40.57       55.79    70.28   81.53
73.11   45.65   79.19    93.55       75.29    69.87   74.68
60.68   41.85   92.18    91.69       81.32    90.38   74.51
48.60   82.14   73.82    41.03       0.99     67.22   93.18
89.13   44.47   57.63    89.36       13.89    19.88   46.60

filename = 'weeklydata.txt';
delimiterIn = ' ';
headerlinesIn = 1;
A = importdata(filename,delimiterIn,headerlinesIn);

% View data
for k = [1:7]
   disp(A.colheaders{1, k})
   disp(A.data(:, k))
   disp(' ')
end

SunDay
   95.0100
   73.1100
   60.6800
   48.6000
   89.1300
 
MonDay
   76.2100
   45.6500
   41.8500
   82.1400
   44.4700
 
TuesDay
   61.5400
   79.1900
   92.1800
   73.8200
   57.6300

WednesDay
   40.5700
   93.5500
   91.6900
   41.0300
   89.3600
 
ThursDay
   55.7900
   75.2900
   81.3200
   0.9900
   13.8900
 
FriDay
   70.2800
   69.8700
   90.3800
   67.2200
   19.8800

SaturDay
   81.5300
   74.6800
   74.5100
   93.1800
   46.6000

A = importdata('-pastespecial')

A = 
   'Mathematics is simple'