Как найти среднее арифметическое значение элементов матрицы

Description

A = [0 1 1; 2 3 2; 1 3 2; 4 2 2]

A = 4×3

     0     1     1
     2     3     2
     1     3     2
     4     2     2

M = 1×3

    1.7500    2.2500    1.7500

A = [0 1 1; 2 3 2; 3 0 1; 1 2 3]

A = 4×3

     0     1     1
     2     3     2
     3     0     1
     1     2     3

M = 4×1

    0.6667
    2.3333
    1.3333
    2.0000

rng('default')
A = randi(10,[4,2,3]);
M = mean(A,2)

M = 
M(:,:,1) =

    8.0000
    5.5000
    2.5000
    8.0000


M(:,:,2) =

   10.0000
    7.5000
    5.5000
    6.0000


M(:,:,3) =

    6.0000
    5.5000
    8.5000
   10.0000

A(:,:,1) = [2 4; -2 1];
A(:,:,2) = [9 13; -5 7];
A(:,:,3) = [4 4; 8 -3];
M1 = mean(A,[1 2])

M1 = 
M1(:,:,1) =

    1.2500


M1(:,:,2) =

     6


M1(:,:,3) =

    3.2500

A = single(ones(10,1));
M = mean(A,"native")

A = [1.77 -0.005 NaN -2.95; NaN 0.34 NaN 0.19]

A = 2×4

    1.7700   -0.0050       NaN   -2.9500
       NaN    0.3400       NaN    0.1900

M = 1×4

    1.7700    0.1675       NaN   -1.3800

function timingMean
A = rand(10,1);
for i = 1:8e5
    mean(A);
end
end

mean

Описание

A = [0 1 1; 2 3 2; 1 3 2; 4 2 2]

A = 4×3

     0     1     1
     2     3     2
     1     3     2
     4     2     2

M = 1×3

    1.7500    2.2500    1.7500

A = [0 1 1; 2 3 2; 3 0 1; 1 2 3]

A = 4×3

     0     1     1
     2     3     2
     3     0     1
     1     2     3

M = 4×1

    0.6667
    2.3333
    1.3333
    2.0000

rng('default')
A = randi(10,[4,2,3]);
M = mean(A,2)

M = 
M(:,:,1) =

    8.0000
    5.5000
    2.5000
    8.0000


M(:,:,2) =

   10.0000
    7.5000
    5.5000
    6.0000


M(:,:,3) =

    6.0000
    5.5000
    8.5000
   10.0000

A(:,:,1) = [2 4; -2 1];
A(:,:,2) = [9 13; -5 7];
A(:,:,3) = [4 4; 8 -3];
M1 = mean(A,[1 2])

M1 = 
M1(:,:,1) =

    1.2500


M1(:,:,2) =

     6


M1(:,:,3) =

    3.2500

A = single(ones(10,1));
M = mean(A,'native')

A = [1 0 0 1 NaN 1 NaN 0];
M = mean(A,'omitnan')

Представлено до R2006a

Специальные матричные функции

Основные функции для работы с матрицами рассмотрены в статье Массивы в Scilab.
Другие полезные функции рассмотрены в статье Функции для решения задач линейной алгебры в Scilab

Ниже остановимся на специальных функциях: поиска минимального и максимального элементов, сортировки, объединения массивов в Scilab и т.д..

Задание матриц/векторов специального вида

Создаём матрицу из единиц: функция ones(n,m) в Scilab

Указываем число строк и число столбцов матрицы.

Задаём вектор-строк и вектор-столбец единиц

R = ones(1,3);  
C = ones(3,1); 

(
begin{matrix}
R = begin{pmatrix}
1 & 1 & 1
end{pmatrix} &
C = begin{pmatrix}
1 \ 1 \ 1
end{pmatrix}
end{matrix}
)

Задаём матрицу из единиц размерностью m на n

A = ones(3, 2);  
S = ones(2, 2); 

(
begin{matrix}
A = begin{pmatrix}
1 & 1 \
1 & 1 \
1 & 1
end{pmatrix} &
S = begin{pmatrix}
1 & 1 \
1 & 1
end{pmatrix}
end{matrix}
)

Задаём матрицу D из единиц, той же размерности, что и матрица A

A = [1 2 3;4 5 6];
D = ones(M);

(
begin{matrix}
A = begin{pmatrix}
1 & 5 & 4 \
3 & 2 & 6
end{pmatrix} &
D = begin{pmatrix}
1 & 1 & 1\
1 & 1 & 1
end{pmatrix}
end{matrix}
)

Создаём матрицу из нулей: функция zeros(n,m) в Scilab

Указываем число строк и число столбцов матрицы.

Задаём вектор-строк и вектор-столбец нулей

R = zeros(1,3);  
C = zeros(3,1); 

(
begin{matrix}
R = begin{pmatrix}
0 & 0 & 0
end{pmatrix} &
C = begin{pmatrix}
0 \ 0 \ 0
end{pmatrix}
end{matrix}
)

Задаём матрицу нулей размерностью m на n

A = zeros(3, 2);  
S = zeros(2, 2); 

(
begin{matrix}
A = begin{pmatrix}
0 & 0 \
0 & 0 \
0 & 0
end{pmatrix} &
S = begin{pmatrix}
0 & 0 \
0 & 0
end{pmatrix}
end{matrix}
)

Задаём матрицу D из нулей, той же размерности, что и матрица A

A = [1 5 4;3 2 6];
D = zeros(M);

(
begin{matrix}
A = begin{pmatrix}
1 & 5 & 4 \
3 & 2 & 6
end{pmatrix} &
D = begin{pmatrix}
0 & 0 & 0\
0 & 0 & 0
end{pmatrix}
end{matrix}
)

Создаём единичную матрицу: функция eye(n,m) в Scilab

Указываем число строк и число столбцов матрицы.

Задаём единичную матрицу нулей размерностью m на n

A = eye(3, 3);  
B = eye(3, 4); 
V = eye(3,1)

(
begin{matrix}
A = begin{pmatrix}
1 & 0 & 0\
0 & 1 & 0\
0 & 0 & 1
end{pmatrix} &
B = begin{pmatrix}
1 & 0 & 0 & 0\
0 & 1 & 0 & 0\
0 & 0 & 1 & 0
end{pmatrix} &
V = begin{pmatrix}
1 \
0 \
0
end{pmatrix}
end{matrix}
)

Задаём единичную матрицу D, той же размерности, что и матрица A

A = [1 2;4 5];
D = eye(M);

(
begin{matrix}
A = begin{pmatrix}
1 & 2 \
4 & 5
end{pmatrix} &
D = begin{pmatrix}
1 & 0 \
0 & 1
end{pmatrix}
end{matrix}
)

Создаём случайную матрицу/вектор: функция rand(n,m, key) в Scilab

Указываем число строк и число столбцов матрицы и необязательный параметр key – это символьная переменная с помощью которой можно задать тип распределения случайной величины (по умолчанию равномерное – ‘uniform’: гауссовское – ‘normal’).

Задаём матрицу m на n случайных чисел

A = rand(3, 2);  
V = rand(3,1,'normal');

(
begin{matrix}
A = begin{pmatrix}
0.2113249 & 0.3303271\
0.7560439 & 0.6653811 \
0.0002211 & 0.6283918
end{pmatrix} &
V = begin{pmatrix}
-0.7335813 \
0.1034169 \
0.8915736
end{pmatrix}
end{matrix}
)

Создаём квадратную матрицу с элемнтами V на k-oй диагонали: функция diag(V[,k]) в Scilab

Задаём вектор V и указываем, на какой диагонали его разместить.

V = [1 2 3];
A = diag(V);  

(
begin{matrix}
A = begin{pmatrix}
1 & 0 & 0\
0 & 2 & 0\
0 & 0 & 3
end{pmatrix}
end{matrix}
)

V = [1 2 3];
В = diag(V, 1);
С = diag(V, -1);  

(
begin{matrix}
B = begin{pmatrix}
0 & 1 & 0 & 0\
0 & 0 & 2 & 0\
0 & 0 & 0 & 3 \
0 & 0 & 0 & 0
end{pmatrix} &
C = begin{pmatrix}
0 & 0 & 0 & 0\
1 & 0 & 0 & 0\
0 & 2 & 0 & 0\
0 & 0 & 3 & 0
end{pmatrix}
end{matrix}
)

Создаём нижне-треугольную матрицу: функция tril(A[,k]) в Scilab

Указывавем матрицу, из которой будем формировать нижне-треугольную и диагональ, с которой начинать

A = [1 1 1; 2 2 2; 3 3 3];
B1 = tril(A);
B2 = tril(A, 1);
B3 = tril(A, -1);

(
begin{matrix}
A = begin{pmatrix}
1 & 1 & 1\
2 & 2 & 2 \
3 & 3 & 3
end{pmatrix} &
B_1 = begin{pmatrix}
1 & 0 & 0\
2 & 2 & 0 \
3 & 3 & 3
end{pmatrix} &
B_2 = begin{pmatrix}
1 & 1 & 0\
2 & 2 & 2 \
3 & 3 & 3
end{pmatrix} &
B_3 = begin{pmatrix}
0 & 0 & 0\
2 & 0 & 0 \
3 & 3 & 0
end{pmatrix}
end{matrix}
)

Создаём верхне-треугольную матрицу: функции triu(A[,k]) в Scilab

Указывавем матрицу, из которой будем формировать верхне-треугольную и диагональ, с которой начинать

A = [1 1 1; 2 2 2; 3 3 3];
B1 = tril(A);
B2 = tril(A, 2);
B3 = tril(A, -1);

(
begin{matrix}
A = begin{pmatrix}
1 & 1 & 1\
2 & 2 & 2 \
3 & 3 & 3
end{pmatrix} &
B_1 = begin{pmatrix}
1 & 1 & 1\
0 & 2 & 2 \
0 & 0 & 3
end{pmatrix} &
B_2 = begin{pmatrix}
0 & 0 & 1\
0 & 0 & 0 \
0 & 0 & 0
end{pmatrix} &
B_3 = begin{pmatrix}
1 & 1 & 1\
2 & 2 & 2 \
0 & 3 & 3
end{pmatrix}
end{matrix}
)

Создаём разреженную матрицу: функции ( sparse(V_1, V_2) ) в Scilab

( V_1 ) – вектор координат(строка, столбец) ненулевых эелемнтов
( V_2 ) – вектор значений ненулевых эелемнтов

A = sparse([1 2; 2 5; 3 1; 3 4], [8 9 15 11]);
full(A);

(
begin{matrix}
A = begin{pmatrix}
0. & 8. & 0. & 0. & 0.\
0. & 0. & 0. & 0. & 9.\
15. & 0. & 0. & 11. & 0.
end{pmatrix}
end{matrix}
)

Функции преобразования матриц/векторов

Изменяем размер матрицы: функция matrix(A [,n,m]) в Scilab

A = [1 2;3 4;5 6];  

( A = begin{pmatrix}
1 & 2 \
3 & 4 \
5 & 6
end{pmatrix} )

Указываем матрицу, которую меняем, потом число строк и число столбцов новой матрицы.

B1 = matrix(A,2,3);
B2 = matrix(A,3,2);
B3 = matrix(A,1,6);
B4 = matrix(A,6,1);

(
begin{matrix}
B_1 = begin{pmatrix}
1 & 5 & 4 \
3 & 2 & 6
end{pmatrix} &
B_2 = begin{pmatrix}
1 & 2 \
3 & 4 \
5 & 6
end{pmatrix} &
B_3 = begin{pmatrix}
1 & 2 & 3 & 4 & 5 & 6
end{pmatrix} &
B_4 = begin{pmatrix}
1 \ 3 \ 4 \ 5 \ 6
end{pmatrix}
end{matrix}
)

Конкатенация (склейка) матриц/векторов: функция cat(n, A, B) в Scilab

Склеиваем матрицы по строкам, т.е. друг под другом

A = [1 2; 3 4];
B = [5 6; 7 8];
C = cat(1, A, B);  

(
begin{matrix}
A = begin{pmatrix}
1 & 2 \
3 & 4
end{pmatrix} &
B = begin{pmatrix}
5 & 6 \
7 & 8
end{pmatrix} &
C = begin{pmatrix}
1 & 2 \
3 & 4 \
5 & 6 \
7 & 8
end{pmatrix}
end{matrix}
)

Объединяем вектора (массивы) по строкам, т.е. друг под другом

A = [1 2 3 4];
B = [5 6 7 8];
C = cat(1, A, B);  

(
begin{matrix}
A = begin{pmatrix}
1 & 2 & 3 & 4
end{pmatrix} &
B = begin{pmatrix}
5 & 6 & 7 & 8
end{pmatrix} &
C = begin{pmatrix}
1 & 2 & 3 & 4\
5 & 6 & 7 & 8
end{pmatrix}
end{matrix}
)

Склеиваем матрицы по столбцам, т.е. друг за другом

A = [1 2; 3 4];
B = [5 6; 7 8];
C = cat(2, A, B);  

(
begin{matrix}
A = begin{pmatrix}
1 & 2 \
3 & 4
end{pmatrix} &
B = begin{pmatrix}
5 & 6 \
7 & 8
end{pmatrix} &
C = begin{pmatrix}
1 & 2 & 5 & 6 \
3 & 4 & 7 & 8
end{pmatrix}
end{matrix}
)

Объединяем вектора (массивы) по столбцам, т.е. друг за другом

A = [1 2 3 4];
B = [5 6 7 8];
C = cat(2, A, B);  

(
begin{matrix}
A = begin{pmatrix}
1 & 2 & 3 & 4
end{pmatrix} &
B = begin{pmatrix}
5 & 6 & 7 & 8
end{pmatrix} &
C = begin{pmatrix}
1 & 2 & 3 & 4 & 5 & 6 & 7 & 8
end{pmatrix}
end{matrix}
)

Сортируем элементы матриц/векторов: функция gsort(A,option,direction) в Scilab

option – символьная строка. Она задаёт тип требуемой сортировки:
‘r’ – сортируется каждый столбец A
‘c’ – сортируется каждая строка A
‘g’ – сортируются все элементы A. Это значение по умолчанию.

direction – символьная строка. Она задаёт направление сортировки:
‘i’ устанавливает порядок возрастания,
‘d’ устанавливает порядок убывания (по умолчанию).

A = [7 2; 4 10];

B1 = gsort(A, 'r');
B2 = gsort(A, 'c');
B3 = gsort(A); 
B4 = gsort(A, 'c', 'i');

(
begin{matrix}
A = begin{pmatrix}
7 & 2 \
4 & 10
end{pmatrix} &
B_1 = begin{pmatrix}
7 & 10 \
4 & 2
end{pmatrix} &
B_2 = begin{pmatrix}
7 & 2 \
10 & 4
end{pmatrix} &
B_3 = begin{pmatrix}
10 & 4 \
7 & 2
end{pmatrix} &
B_4 = begin{pmatrix}
2 & 7 \
4 & 10
end{pmatrix}
end{matrix}
)

Функции вычисления различных характеристик матриц/векторов

Определяем размер матриц/векторов: функция size(A,option) в Scilab

option – символьная строка. Она возволяет определить:
‘r’ – число строк матрицы A
‘c’ – число столбцов матрицы A.

A = [7 2 1; 3 4 10];
  
[m, n] = size(A);
  
m = size(A, 'r');
n = size(A, 'c');

(
begin{matrix}
A = begin{pmatrix}
7 & 2 & 1\
3 & 4 & 10
end{pmatrix} &
m = 2 & n = 3
end{matrix}
)

Найдём сумму элементов массива/матрицы: функция sum(A,option) в Scilab

option – символьная строка. Она возволяет определить:
‘r’ – поэлементную сумму строк матрицы A. Возвращает строку.
‘c’ – поэлементную сумму столбцов матрицы A. Возвращает столбец.

Если option отсутствует, то возвращается сумма всех элементов.

A = [7 2 1; 3 4 10];
  
R = sum(A, 'r');
V = sum(A, 'c');
S = sum(A);

(
begin{matrix}
A = begin{pmatrix}
7 & 2 & 1\
3 & 4 & 10
end{pmatrix} &
R = begin{pmatrix}
10 & 6 & 11
end{pmatrix}&
V = begin{pmatrix}
10 \ 17
end{pmatrix} &
S = 27
end{matrix}
)

Найдём произведение элементов массива/матрицы: функция prod(A,option) в Scilab

option – символьная строка. Она возволяет определить:
‘r’ – поэлементное произведение строк матрицы A. Возвращает строку.
‘c’ – поэлементное произведение столбцов матрицы A. Возвращает столбец.

Если option отсутствует, то возвращается произведение всех элементов.

A = [7 2 1; 3 4 10];
  
R = sum(A, 'r');
V = sum(A, 'c');
P = sum(A);

(
begin{matrix}
A = begin{pmatrix}
7 & 2 & 1\
3 & 4 & 10
end{pmatrix} &
R = begin{pmatrix}
21 & 8 & 10
end{pmatrix}&
V = begin{pmatrix}
14 \ 120
end{pmatrix} &
P = 1680
end{matrix}
)

Найдём наибольший элемент массива/матрицы: функция max(A,option) в Scilab

option – символьная строка. Она возволяет определить:
‘r’ – наибольший элемент в каждом столбце матрицы A. Возвращает строку.
‘c’ – наибольший элемент в каждой строке матрицы A. Возвращает столбец.

Если option отсутствует, то возвращается наибольший элемент во всей матрице.

A = [7 2 1; 3 4 10];
  
R = max(A, 'r');
V = max(A, 'c');
M = max(A);

(
begin{matrix}
A = begin{pmatrix}
7 & 2 & 1\
3 & 4 & 10
end{pmatrix} &
R = begin{pmatrix}
7 & 4 & 10
end{pmatrix}&
V = begin{pmatrix}
7 \ 10
end{pmatrix} &
M = 10
end{matrix}
)

Найдём наименьший элемент массива/матрицы: функция min(A,option) в Scilab

option – символьная строка. Она возволяет определить:
‘r’ – наименьший элемент в каждом столбце матрицы A. Возвращает строку.
‘c’ – наименьший элемент в каждой строке матрицы A. Возвращает столбец.

Если option отсутствует, то возвращается наименьший элемент во всей матрице.

A = [7 2 1; 3 4 10];
  
R = min(A, 'r');
V = min(A, 'c');
M = min(A);

(
begin{matrix}
A = begin{pmatrix}
7 & 2 & 1\
3 & 4 & 10
end{pmatrix} &
R = begin{pmatrix}
3 & 2 & 1
end{pmatrix}&
V = begin{pmatrix}
1 \ 3
end{pmatrix} &
M = 1
end{matrix}
)

Найдём среднее значение массива/матрицы: функция mean(A,option) в Scilab

option – символьная строка. Она возволяет определить:
‘r’ – среднее значение в каждом столбце матрицы A. Возвращает строку.
‘c’ – среднее значение в каждой строке матрицы A. Возвращает столбец.

Если option отсутствует, то возвращается среднее значение всей матрицы.

A = [7 2 1; 3 4 10];
  
R = mean(A, 'r');
V = mean(A, 'c');
M = mean(A);

(
begin{matrix}
A = begin{pmatrix}
7 & 2 & 1\
3 & 4 & 10
end{pmatrix} &
R = begin{pmatrix}
5 & 3 & 5.5
end{pmatrix}&
V = begin{pmatrix}
3.3333 \ 5.6666
end{pmatrix} &
M = 4.5
end{matrix}
)

Основные функции для работы с матрицами рассмотрены в статье Массивы в Scilab.