mtimes, *

Moltiplicazione di matrici

Sintassi

C = A*B

C = mtimes(A,B)

Descrizione

C = A*B è il prodotto matriciale di A e B. Se A è una matrice m x p e B è una matrice p x n, C è una matrice m x n definita da

$$C(i,j)={\displaystyle \sum _{k=1}^{p}A}(i,k)B(k,j).$$

Questa definizione dice che C(i,j) è il prodotto interno dell'i-esima riga di A con la j-esima colonna di B. È possibile scrivere questa definizione utilizzando l'operatore due punti di MATLAB^® come

C(i,j) = A(i,:)*B(:,j)

Per A e B non scalari, il numero di colonne di A deve essere uguale al numero di righe di B. La moltiplicazione di matrici non è universalmente commutativa per input non scalari. Ossia A*B, non è solitamente uguale a B*A. Se almeno un input è scalare, A*B è equivalente a A.*B ed è commutativo.

C = mtimes(A,B) è un modo alternativo per eseguire A*B, ma è utilizzato di rado. Consente il sovraccarico degli operatori per le classi.

Esempi

Moltiplicazione di due vettori

Creare un vettore riga 1x 4 A e un vettore colonna 4x1 B.

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

Moltiplicare A per B.

C = A*B

C = 
3

Il risultato è uno scalare 1x1, chiamato anche prodotto scalare o prodotto interno dei vettori A e B. In alternativa, è possibile calcolare il prodotto scalare $$A\cdot B$$ con la sintassi dot(A,B).

Moltiplicare B per A.

C = B*A

C = 4×4

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

Il risultato è una matrice 4x4, chiamata anche prodotto esterno dei vettori A e B. Il prodotto esterno di due vettori $$A\otimes B$$, restituisce una matrice.

Moltiplicazione di due array

Creare due array, A e B.

A = [1 3 5; 2 4 7];
B = [-5 8 11; 3 9 21; 4 0 8];

Calcolare il prodotto di A e B.

C = A*B

C = 2×3

    24    35   114
    30    52   162

Calcolare il prodotto interno della seconda riga di A e della terza colonna di B.

A(2,:)*B(:,3)

ans = 
162

Questa risposta equivale a C(2,3).

Argomenti di input

A, B — Operandi

scalari | vettori | matrici

Operandi, specificati come scalari, vettori o matrici.

• Se almeno un input è scalare, A*B è equivalente a A.*B. In questo caso, l'array non scalare può avere qualsiasi dimensione.

• Per input non scalari, A e B devono essere array bidimensionali in cui il numero di colonne in A deve essere uguale al numero di righe in B.

• Se A o B è una classe a numero intero (int16, uint8, …), l'altro input deve essere uno scalare. Gli operandi con un tipo di dato a numero intero non possono essere complessi.

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical | char | duration | calendarDuration
Supporto numeri complessi: Sì

Argomenti di output

C — Prodotto

scalare | vettore | matrice

Prodotto, restituito come scalare, vettore o matrice. L'array C ha lo stesso numero di righe dell'input A e lo stesso numero di colonne dell'input B. Ad esempio, se A è una matrice vuota m x 0 e B è una matrice vuota 0 x n, A*B è una matrice m x n di zeri.

Suggerimenti

• Con moltiplicazioni di matrici concatenate come A*B*C, è possibile migliorare i tempi di esecuzione utilizzando le parentesi per stabilire l'ordine delle operazioni. Si consideri il caso della moltiplicazione di tre matrici con A*B*C, dove A è 500x2, B è 2x500 e C è 500x2.

  • In assenza di parentesi, l'ordine delle operazioni è da sinistra verso destra, quindi viene calcolato prima A*B che produce una matrice 500x500. Questa matrice viene quindi moltiplicata per C per ottenere il risultato 500x2.

  • Se invece si specifica A*(B*C), B*C viene moltiplicato per primo, producendo una matrice 2x2. La matrice piccola moltiplica quindi A per produrre lo stesso risultato 500x2, ma con meno operazioni e minore utilizzo di memoria intermedia.

Riferimenti

[1] “BLAS (Basic Linear Algebra Subprograms).” Accessed July 18, 2022. https://netlib.org/blas/.

[2] Davis, Timothy A. “Algorithm 1000: SuiteSparse:GraphBLAS: Graph Algorithms in the Language of Sparse Linear Algebra.” ACM Transactions on Mathematical Software 45, no. 4 (December 31, 2019): 1–25. https://doi.org/10.1145/3322125.

Funzionalità estese

Tall array

Esegui calcoli con array che hanno più righe di quelle allocabili in memoria.

Questa funzione supporta i tall array con le seguenti limitazioni:

• Per A*B dove A e B sono entrambi tall array, uno dei due deve essere uno scalare.

• Per A'*B, sia A che B devono essere vettori o matrici tall con una grandezza comune nella prima dimensione.

Per maggiori informazioni, vedere Tall Array.

Generazione di codice C/C++

Genera codice C e C++ con MATLAB® Coder™.

Note su utilizzo e limitazioni:

• Se si moltiplica una matrice che contiene numeri immaginari puri per una matrice che contiene valori non finiti, i risultati prodotti dal codice generato potrebbero non corrispondere a quelli prodotti da MATLAB. Vedere Results of Complex Multiplication with Nonfinite Values (MATLAB Coder).

• Se si definiscono uno o entrambi gli operandi come matrici a grandezza variabile al momento della generazione di codice, il generatore di codice produce codice per la moltiplicazione matrice-matrice. Se uno di questi operandi è uno scalare in fase di esecuzione, si verifica un errore di runtime. Per evitare questo errore, specificare gli operandi che sono scalari in fase di esecuzione come scalari a grandezza fissa al momento della generazione di codice.

Generazione di codice GPU

Genera codice CUDA® per GPU NVIDIA® con GPU Coder™.

Note su utilizzo e limitazioni:

• La moltiplicazione di numeri immaginari puri per numeri non finiti potrebbe non corrispondere a MATLAB. Il generatore di codice non è specializzato nella moltiplicazione di numeri immaginari puri, ossia non elimina i calcoli con parte reale pari a zero. Ad esempio, (Inf + 1i)*1i = (Inf*0 – 1*1) + (Inf*1 + 1*0)i = NaN + Infi.

Generazione di codice HDL
Genera codice VHDL, Verilog e SystemVerilog per progetti FPGA e ASIC utilizzando HDL Coder™.

Ambiente basato su thread

Esegui il codice in background usando MATLAB® backgroundPool oppure accelera il codice con Parallel Computing Toolbox™ ThreadPool.

La funzione mtimes supporta completamente gli ambienti basati su thread. Per maggiori informazioni, vedere Run MATLAB Functions in Thread-Based Environment.

Array GPU

Accelera il codice mediante esecuzione su un’unità di elaborazione grafica (GPU) con Parallel Computing Toolbox™.

La funzione mtimes supporta l'input di array GPU con queste note su utilizzo e limitazioni:

• La moltiplicazione matrice-vettore non è deterministica quando la matrice è sparsa e trasposta utilizzando una delle sintassi riportate nella tabella sottostante. Per ottenere risultati deterministici, trasporre la matrice utilizzando le funzioni transpose o ctranspose anziché gli operatori .' e '.

  Operazione non deterministica	Equivalente deterministica
  A'*v	ctranspose(A)*v
  A.'*v	transpose(A)*v
  v*A'	v*ctranspose(A)
  v*A.'	v*transpose(A)

Per maggiori informazioni, vedere Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

Array distribuiti

Partiziona array di grandi dimensioni nella memoria combinata del cluster con Parallel Computing Toolbox™.

La funzione mtimes supporta completamente gli array distribuiti. Per maggiori informazioni, vedere Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

Cronologia versioni

Introduzione prima di R2006a

R2026a: Miglioramento delle prestazioni del codice generato per la moltiplicazione di matrici

MATLAB Coder™ migliora le prestazioni in runtime del codice C/C++ MEX e standalone generato per mtimes.

Ad esempio, la funzione C MEX generata per sparseMtimes è approssimativamente 4 volte più veloce rispetto alla release precedente:

function y = sparseMtimes(a,b)
	y = a*b;
end

rng(10,"twister")
a = sprandn(1000,1000,0.1);
b = sprandn(1000,1000,0.1);
coder.timeit("sparseMtimes.m",1,{a,b})

I tempi di esecuzione approssimativi sono:

• R2025b: 0,0665 ms

• R2026a: 0,0168 ms

Il codice è stato cronometrato su un processore Windows^® 11, Intel^® Xeon^® W-2133 CPU @ 3.60GHz 6-Core utilizzando la funzione coder.timeit (MATLAB Coder).

R2022a: Miglioramento delle prestazioni nella moltiplicazione di matrici sparse e complete

La moltiplicazione di matrici mostra un miglioramento delle prestazioni quando:

• Uno degli operandi è una matrice sparsa, mentre l'altro è una matrice completa.

• L'operando sparso ha almeno 50.000 elementi diversi da zero.

• L'operando completo ha almeno 32 colonne (o almeno 32 righe se trasposto).

Il miglioramento delle prestazioni deriva dall'ulteriore supporto per il multithread nell'operazione e, di conseguenza, l'accelerazione aumenta all'aumentare della dimensione della matrice e del numero di elementi diversi da zero.

Ad esempio, moltiplicare una matrice sparsa 102.400x102.400 con una matrice completa 102.400x128 su una macchina con 6 core fisici è circa 2,7 volte più veloce rispetto alla release precedente.

function timingSparseDenseMult
A = delsq(numgrid('S',322));
B = rand(size(A,2),128);
tic
for k = 1:10
    C = A*B;
end
toc
end

I tempi di esecuzione approssimativi sono:

R2021b: 0,8 s

R2022a: 0,3 s

Il codice è stato cronometrato su un sistema di test Windows 10, Intel Xeon CPU W-2133 @ 3.60 GHz chiamando la funzione timingSparseDenseMult.

Vedi anche

colon | times | dot | cross | pagemtimes | tensorprod

Argomenti

• Operazioni su array vs operazioni matriciali
• Operator Precedence
• Operatori e caratteri speciali di MATLAB